From b26a5c60c8673b2a08a2dea1bf2aef63ca2df5b5 Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Tue, 20 Sep 2022 10:52:03 +0200 Subject: [PATCH] [jOOQ/jOOQ#10212] Add options to generate non-null attributes on Records, Pojos, and interfaces in KotlinGenerator This includes: - [jOOQ/jOOQ#14002] KotlinGenerator shouldn't generate public default constructor if non-nullable attributes are generated on records --- .../org/jooq/codegen/AbstractGenerator.java | 33 +++++ .../java/org/jooq/codegen/GenerationTool.java | 6 + .../main/java/org/jooq/codegen/Generator.java | 33 +++++ .../java/org/jooq/codegen/JavaGenerator.java | 127 +++++++++++++----- .../java/org/jooq/meta/jaxb/Generate.java | 126 +++++++++++++++++ .../org/jooq/meta/xsd/jooq-codegen-3.18.0.xsd | 12 ++ 6 files changed, 300 insertions(+), 37 deletions(-) diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractGenerator.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractGenerator.java index 72f5cc8d07..9ae1ecfdde 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractGenerator.java +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractGenerator.java @@ -113,6 +113,9 @@ abstract class AbstractGenerator implements Generator { boolean generateSpringAnnotations = false; boolean generateSpringDao = false; boolean generateKotlinSetterJvmNameAnnotationsOnIsPrefix = true; + boolean generateKotlinNotNullPojoAttributes = false; + boolean generateKotlinNotNullRecordAttributes = false; + boolean generateKotlinNotNullInterfaceAttributes = false; GeneratedSerialVersionUID generatedSerialVersionUID = GeneratedSerialVersionUID.CONSTANT; int maxMembersPerInitialiser = 500; boolean generateQueues = true; @@ -738,6 +741,36 @@ abstract class AbstractGenerator implements Generator { this.generateKotlinSetterJvmNameAnnotationsOnIsPrefix = generateKotlinSetterJvmNameAnnotationsOnIsPrefix; } + @Override + public boolean generateKotlinNotNullPojoAttributes() { + return generateKotlinNotNullPojoAttributes; + } + + @Override + public void setGenerateKotlinNotNullPojoAttributes(boolean generateKotlinNotNullPojoAttributes) { + this.generateKotlinNotNullPojoAttributes = generateKotlinNotNullPojoAttributes; + } + + @Override + public boolean generateKotlinNotNullRecordAttributes() { + return generateKotlinNotNullRecordAttributes; + } + + @Override + public void setGenerateKotlinNotNullRecordAttributes(boolean generateKotlinNotNullRecordAttributes) { + this.generateKotlinNotNullRecordAttributes = generateKotlinNotNullRecordAttributes; + } + + @Override + public boolean generateKotlinNotNullInterfaceAttributes() { + return generateKotlinNotNullInterfaceAttributes; + } + + @Override + public void setGenerateKotlinNotNullInterfaceAttributes(boolean generateKotlinNotNullInterfaceAttributes) { + this.generateKotlinNotNullInterfaceAttributes = generateKotlinNotNullInterfaceAttributes; + } + @Override public GeneratedSerialVersionUID generatedSerialVersionUID() { return generatedSerialVersionUID; diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/GenerationTool.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/GenerationTool.java index bfae8e7ef6..806d551e0e 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/codegen/GenerationTool.java +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/GenerationTool.java @@ -808,6 +808,12 @@ public class GenerationTool { generator.setGenerateSpringDao(g.getGenerate().isSpringDao()); if (g.getGenerate().isKotlinSetterJvmNameAnnotationsOnIsPrefix() != null) generator.setGenerateKotlinSetterJvmNameAnnotationsOnIsPrefix(g.getGenerate().isKotlinSetterJvmNameAnnotationsOnIsPrefix()); + if (g.getGenerate().isKotlinNotNullPojoAttributes() != null) + generator.setGenerateKotlinNotNullPojoAttributes(g.getGenerate().isKotlinNotNullPojoAttributes()); + if (g.getGenerate().isKotlinNotNullRecordAttributes() != null) + generator.setGenerateKotlinNotNullRecordAttributes(g.getGenerate().isKotlinNotNullRecordAttributes()); + if (g.getGenerate().isKotlinNotNullInterfaceAttributes() != null) + generator.setGenerateKotlinNotNullInterfaceAttributes(g.getGenerate().isKotlinNotNullInterfaceAttributes()); if (g.getGenerate().getGeneratedSerialVersionUID() != null) generator.setGenerateGeneratedSerialVersionUID(g.getGenerate().getGeneratedSerialVersionUID()); if (g.getGenerate().getMaxMembersPerInitialiser() != null) diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/Generator.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/Generator.java index c56a6f172a..3ce6b82198 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/codegen/Generator.java +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/Generator.java @@ -600,6 +600,39 @@ public interface Generator { */ void setGenerateKotlinSetterJvmNameAnnotationsOnIsPrefix(boolean generateKotlinSetterJvmNameAnnotationsOnIsPrefix); + /** + * Generate non-nullable types on POJO attributes, where column is not null. + */ + boolean generateKotlinNotNullPojoAttributes(); + + /** + * Generate non-nullable types on POJO attributes, where column is not null. + */ + void setGenerateKotlinNotNullPojoAttributes(boolean generateKotlinNotNullPojoAttributes); + + /** + * Generate non-nullable types on Record attributes, where column is not + * null. + */ + boolean generateKotlinNotNullRecordAttributes(); + + /** + * Generate non-nullable types on Record attributes, where column is not + * null. + */ + void setGenerateKotlinNotNullRecordAttributes(boolean generateKotlinNotNullRecordAttributes); + + /** + * Generate non-nullable types on interface attributes, where column is not + * null. + */ + boolean generateKotlinNotNullInterfaceAttributes(); + + /** + * Generate non-nullable types on interface attributes, where column is not null. + */ + void setGenerateKotlinNotNullInterfaceAttributes(boolean generateKotlinNotNullInterfaceAttributes); + /** * The type of serialVersionUID that should be generated. */ diff --git a/jOOQ-codegen/src/main/java/org/jooq/codegen/JavaGenerator.java b/jOOQ-codegen/src/main/java/org/jooq/codegen/JavaGenerator.java index 2fc47d0d8e..a1d495067c 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/codegen/JavaGenerator.java +++ b/jOOQ-codegen/src/main/java/org/jooq/codegen/JavaGenerator.java @@ -1540,7 +1540,7 @@ public class JavaGenerator extends AbstractGenerator { if (generateInterfaces()) interfaces.add(out.ref(getStrategy().getFullJavaClassName(tableUdtOrEmbeddable, Mode.INTERFACE))); - if (scala) + if (scala) { if (tableUdtOrEmbeddable instanceof EmbeddableDefinition) out.println("%sclass %s extends %s[%s](%s.%s.getDataType.getRow)[[before= with ][separator= with ][%s]] {", visibility(), @@ -1560,11 +1560,14 @@ public class JavaGenerator extends AbstractGenerator { tableIdentifier, interfaces ); - else if (kotlin) + } + else if (kotlin) { + String constructorVisibility = generateKotlinNotNullRecordAttributes() ? " private constructor" : ""; if (tableUdtOrEmbeddable instanceof EmbeddableDefinition) - out.println("%sopen class %s() : %s<%s>(%s.%s.dataType.row)[[before=, ][%s]] {", + out.println("%sopen class %s%s() : %s<%s>(%s.%s.dataType.row)[[before=, ][%s]] {", visibility(), className, + constructorVisibility, baseClass, className, out.ref(getStrategy().getFullJavaIdentifier(((EmbeddableDefinition) tableUdtOrEmbeddable).getTable()), 2), @@ -1572,14 +1575,16 @@ public class JavaGenerator extends AbstractGenerator { interfaces ); else - out.println("%sopen class %s() : %s<%s>(%s)[[before=, ][%s]] {", + out.println("%sopen class %s%s() : %s<%s>(%s)[[before=, ][%s]] {", visibility(), className, + constructorVisibility, baseClass, className, tableIdentifier, interfaces ); + } else out.println("%sclass %s extends %s<%s>[[before= implements ][%s]] {", visibility(), className, baseClass, className, interfaces); @@ -1788,7 +1793,7 @@ public class JavaGenerator extends AbstractGenerator { } else if (kotlin) { printDeprecationIfUnknownType(out, colTypeFull); - out.println("%soverride fun component%s(): %s? = %s", visibilityPublic(), i, colType, colMember); + out.println("%soverride fun component%s(): %s%s = %s", visibilityPublic(), i, colType, kotlinNullability(out, (TypedElementDefinition) column, Mode.RECORD), colMember); } else { if (printDeprecationIfUnknownType(out, colTypeFull)) @@ -1818,7 +1823,7 @@ public class JavaGenerator extends AbstractGenerator { } else if (kotlin) { printDeprecationIfUnknownType(out, colTypeFull); - out.println("%soverride fun value%s(): %s? = %s", visibilityPublic(), i, colType, colMember); + out.println("%soverride fun value%s(): %s%s = %s", visibilityPublic(), i, colType, kotlinNullability(out, (TypedElementDefinition) column, Mode.RECORD), colMember); } else { if (printDeprecationIfUnknownType(out, colTypeFull)) @@ -2091,7 +2096,12 @@ public class JavaGenerator extends AbstractGenerator { arguments.add(columnMember + " : " + type); } else if (kotlin) { - arguments.add(columnMember + ": " + type + "? = null"); + String nullability = column instanceof TypedElementDefinition ted ? kotlinNullability(out, ted, Mode.RECORD) : ""; + + if (nullability.isEmpty()) + arguments.add(columnMember + ": " + type); + else + arguments.add(columnMember + ": " + type + "? = null"); } else { final String nullableAnnotation = column instanceof EmbeddableDefinition @@ -2425,7 +2435,7 @@ public class JavaGenerator extends AbstractGenerator { printValidationAnnotation(out, column); printKotlinSetterAnnotation(out, column, Mode.RECORD); - out.println("%sopen %svar %s: %s?", visibility(generateInterfaces()), (generateInterfaces() ? "override " : ""), member, type); + out.println("%sopen %svar %s: %s%s", visibility(generateInterfaces()), (generateInterfaces() ? "override " : ""), member, type, kotlinNullability(out, column, Mode.RECORD)); out.tab(1).println("set(value): %s = set(%s, value)", setterReturnType, index); } else { @@ -2619,7 +2629,7 @@ public class JavaGenerator extends AbstractGenerator { out.println("%sdef %s: %s = get(%s).asInstanceOf[%s]", visibility(override), scalaWhitespaceSuffix(getter), type, index, type); } else if (kotlin) { - String nullable = column instanceof EmbeddableDefinition ? "" : "?"; + String nullable = column instanceof EmbeddableDefinition ? "" : kotlinNullability(out, column, Mode.RECORD); out.tab(1).println("get(): %s%s = get(%s) as %s%s", type, nullable, index, type, nullable); } else { @@ -2691,7 +2701,7 @@ public class JavaGenerator extends AbstractGenerator { if (scala) out.println("get(%s).asInstanceOf[%s]%s", position, columnType, separator); else if (kotlin) - out.tab(1).println("get(%s) as %s?%s", position, columnType, separator); + out.tab(1).println("get(%s) as %s%s%s", position, columnType, kotlinNullability(out, column, Mode.RECORD), separator); else { // [#6705] Avoid generating code with a redundant (Object) cast @@ -3024,7 +3034,7 @@ public class JavaGenerator extends AbstractGenerator { if (scala) out.println("%sdef %s: %s", visibilityPublic(), scalaWhitespaceSuffix(getter), type); else if (kotlin) - out.println("%s%s %s: %s?", visibilityPublic(), (generateImmutableInterfaces() ? "val" : "var"), member, type); + out.println("%s%s %s: %s%s", visibilityPublic(), (generateImmutableInterfaces() ? "val" : "var"), member, type, kotlinNullability(out, column, Mode.INTERFACE)); else out.println("%s%s %s();", visibilityPublic(), type, getter); } @@ -5070,6 +5080,7 @@ public class JavaGenerator extends AbstractGenerator { forEach(getTypedElements(tableUdtOrEmbeddable), (column, separator) -> { final String member = getStrategy().getJavaMemberName(column, Mode.POJO); + final String nullability = kotlinNullability(out, column, Mode.POJO); if (column instanceof ColumnDefinition) printColumnJPAAnnotation(out, (ColumnDefinition) column); @@ -5078,12 +5089,14 @@ public class JavaGenerator extends AbstractGenerator { if (!generateImmutablePojos()) printKotlinSetterAnnotation(out, column, Mode.POJO); - out.println("%s%s%s %s: %s? = null%s", + out.println("%s%s%s %s: %s%s%s%s", visibility(generateInterfaces()), generateInterfaces() ? "override " : "", generateImmutablePojos() ? "val" : "var", member, out.ref(getJavaType(column.getType(resolver(out, Mode.POJO)), out, Mode.POJO)), + nullability, + nullability.isEmpty() ? "" : " = null", separator ); }); @@ -5631,18 +5644,25 @@ public class JavaGenerator extends AbstractGenerator { for (TypedElementDefinition column : getTypedElements(tableOrUDT)) { final String columnMember = getStrategy().getJavaMemberName(column, Mode.POJO); + final boolean nn = kotlinEffectivelyNotNull(out, column, Mode.POJO); + final String else_ = nn ? "" : "else "; - out.println("if (this.%s === null) {", columnMember); - out.println("if (o.%s !== null)", columnMember); - out.println("return false"); - out.println("}"); + if (!nn) { + out.println("if (this.%s === null) {", columnMember); + out.println("if (o.%s !== null)", columnMember); + out.println("return false"); + out.println("}"); + } if (isObjectArrayType(getJavaType(column.getType(resolver(out)), out))) - out.println("else if (!%s.deepEquals(this.%s, o.%s))", Arrays.class, columnMember, columnMember); + out.println("%sif (!%s.deepEquals(this.%s, o.%s))", else_, Arrays.class, columnMember, columnMember); else if (isArrayType(getJavaType(column.getType(resolver(out)), out))) - out.println("else if (!%s.equals(this.%s, o.%s))", Arrays.class, columnMember, columnMember); + out.println("%sif (!%s.equals(this.%s, o.%s))", else_, Arrays.class, columnMember, columnMember); else - out.println("else if (this.%s != o.%s)", columnMember, columnMember); + out.println("%sif (this.%s != o.%s)", else_, columnMember, columnMember); + + if (nn) + out.tab(1); out.println("return false"); } @@ -5710,13 +5730,24 @@ public class JavaGenerator extends AbstractGenerator { for (TypedElementDefinition column : getTypedElements(tableOrUDT)) { final String columnMember = getStrategy().getJavaMemberName(column, Mode.POJO); + final boolean nn = kotlinEffectivelyNotNull(out, column, Mode.POJO); - if (isObjectArrayType(getJavaType(column.getType(resolver(out)), out))) - out.println("result = prime * result + (if (this.%s === null) 0 else %s.deepHashCode(this.%s))", columnMember, Arrays.class, columnMember); - else if (isArrayType(getJavaType(column.getType(resolver(out)), out))) - out.println("result = prime * result + (if (this.%s === null) 0 else %s.hashCode(this.%s))", columnMember, Arrays.class, columnMember); - else - out.println("result = prime * result + (if (this.%s === null) 0 else this.%s.hashCode())", columnMember, columnMember); + if (nn) { + if (isObjectArrayType(getJavaType(column.getType(resolver(out)), out))) + out.println("result = prime * result + %s.deepHashCode(this.%s)", columnMember, Arrays.class, columnMember); + else if (isArrayType(getJavaType(column.getType(resolver(out)), out))) + out.println("result = prime * result + %s.hashCode(this.%s)", columnMember, Arrays.class, columnMember); + else + out.println("result = prime * result + this.%s.hashCode()", columnMember, columnMember); + } + else { + if (isObjectArrayType(getJavaType(column.getType(resolver(out)), out))) + out.println("result = prime * result + (if (this.%s === null) 0 else %s.deepHashCode(this.%s))", columnMember, Arrays.class, columnMember); + else if (isArrayType(getJavaType(column.getType(resolver(out)), out))) + out.println("result = prime * result + (if (this.%s === null) 0 else %s.hashCode(this.%s))", columnMember, Arrays.class, columnMember); + else + out.println("result = prime * result + (if (this.%s === null) 0 else this.%s.hashCode())", columnMember, columnMember); + } } out.println("return result"); @@ -8004,7 +8035,7 @@ public class JavaGenerator extends AbstractGenerator { } String nullable = ""; - if (!column.getType(resolver(out)).isNullable()) + if (effectivelyNotNull(out, column)) nullable = ", nullable = false"; String length = ""; @@ -8054,9 +8085,7 @@ public class JavaGenerator extends AbstractGenerator { DataTypeDefinition type = column.getType(resolver(out)); // [#5128] defaulted columns are nullable in Java - if (!column.getType(resolver(out)).isNullable() && - !column.getType(resolver(out)).isDefaulted() && - !column.getType(resolver(out)).isIdentity()) + if (effectivelyNotNull(out, column)) out.println("@%s%s", prefix, out.ref("jakarta.validation.constraints.NotNull")); String javaType = getJavaType(type, out); @@ -8069,6 +8098,34 @@ public class JavaGenerator extends AbstractGenerator { } } + private String kotlinNullability(JavaWriter out, TypedElementDefinition typed) { + return kotlinNullability(out, typed, Mode.DEFAULT); + } + + private String kotlinNullability(JavaWriter out, TypedElementDefinition typed, Mode mode) { + return kotlinEffectivelyNotNull(out, typed, mode) ? "" : "?"; + } + + private boolean kotlinEffectivelyNotNull(JavaWriter out, TypedElementDefinition typed, Mode mode) { + if (mode == Mode.POJO && generateKotlinNotNullPojoAttributes() || + mode == Mode.RECORD && generateKotlinNotNullRecordAttributes() || + mode == Mode.INTERFACE && generateKotlinNotNullInterfaceAttributes() || + mode == Mode.DEFAULT) + return effectivelyNotNull(out, typed) ? true : false; + else + return false; + } + + private boolean effectivelyNotNull(JavaWriter out, TypedElementDefinition column) { + return effectivelyNotNull(column.getType(resolver(out))); + } + + private boolean effectivelyNotNull(DataTypeDefinition type) { + return !type.isNullable() + && !type.isDefaulted() + && !type.isIdentity(); + } + private static final Pattern P_IS = Pattern.compile("^is[A-Z].*$"); protected void printKotlinSetterAnnotation(JavaWriter out, TypedElementDefinition column, Mode mode) { @@ -8096,13 +8153,13 @@ public class JavaGenerator extends AbstractGenerator { } private String nullableOrNonnullAnnotation(JavaWriter out, Definition column) { - return (column instanceof TypedElementDefinition && ((TypedElementDefinition) column).getType().isNullable()) + return (column instanceof TypedElementDefinition && effectivelyNotNull(out, (TypedElementDefinition) column)) ? nullableAnnotation(out) : nonnullAnnotation(out); } private void printNullableOrNonnullAnnotation(JavaWriter out, Definition column) { - if (column instanceof TypedElementDefinition && ((TypedElementDefinition) column).getType().isNullable()) + if (column instanceof TypedElementDefinition && effectivelyNotNull(out, (TypedElementDefinition) column)) printNullableAnnotation(out); else printNonnullAnnotation(out); @@ -8606,7 +8663,7 @@ public class JavaGenerator extends AbstractGenerator { if (parametersAsField) out.println("%s%s: %s<%s?>", separator, memberName, Field.class, refExtendsNumberType(out, parameter.getType(resolver(out)))); else - out.println("%s%s: %s%s", separator, memberName, refNumberType(out, parameter.getType(resolver(out))), kotlinNullability(parameter)); + out.println("%s%s: %s%s", separator, memberName, refNumberType(out, parameter.getType(resolver(out))), kotlinNullability(out, parameter)); } else { if (parametersAsField) @@ -8688,7 +8745,7 @@ public class JavaGenerator extends AbstractGenerator { if (scala) out.println("%s%s: %s", separator, scalaWhitespaceSuffix(paramMember), paramType); else if (kotlin) - out.println("%s%s: %s%s", separator, paramMember, paramType, kotlinNullability(parameter)); + out.println("%s%s: %s%s", separator, paramMember, paramType, kotlinNullability(out, parameter)); else out.println("%s%s %s", separator, paramType, paramMember); @@ -9687,10 +9744,6 @@ public class JavaGenerator extends AbstractGenerator { return sb.toString(); } - private String kotlinNullability(TypedElementDefinition typed) { - return typed.getType().isNullable() ? "?" : ""; - } - private DataType mapTypes(DataType dataType) { DataType result = dataType; diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Generate.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Generate.java index d547cf5856..e9499ee765 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Generate.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Generate.java @@ -132,6 +132,12 @@ public class Generate implements Serializable, XMLAppendable protected Boolean springDao = false; @XmlElement(defaultValue = "true") protected Boolean kotlinSetterJvmNameAnnotationsOnIsPrefix = true; + @XmlElement(defaultValue = "false") + protected Boolean kotlinNotNullPojoAttributes = false; + @XmlElement(defaultValue = "false") + protected Boolean kotlinNotNullRecordAttributes = false; + @XmlElement(defaultValue = "false") + protected Boolean kotlinNotNullInterfaceAttributes = false; @XmlElement(defaultValue = "true") protected Boolean globalObjectReferences = true; @XmlElement(defaultValue = "true") @@ -1411,6 +1417,78 @@ public class Generate implements Serializable, XMLAppendable this.kotlinSetterJvmNameAnnotationsOnIsPrefix = value; } + /** + * Generate non-nullable types on POJO attributes, where column is not null. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isKotlinNotNullPojoAttributes() { + return kotlinNotNullPojoAttributes; + } + + /** + * Sets the value of the kotlinNotNullPojoAttributes property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setKotlinNotNullPojoAttributes(Boolean value) { + this.kotlinNotNullPojoAttributes = value; + } + + /** + * Generate non-nullable types on Record attributes, where column is not null. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isKotlinNotNullRecordAttributes() { + return kotlinNotNullRecordAttributes; + } + + /** + * Sets the value of the kotlinNotNullRecordAttributes property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setKotlinNotNullRecordAttributes(Boolean value) { + this.kotlinNotNullRecordAttributes = value; + } + + /** + * Generate non-nullable types on interface attributes, where column is not null. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isKotlinNotNullInterfaceAttributes() { + return kotlinNotNullInterfaceAttributes; + } + + /** + * Sets the value of the kotlinNotNullInterfaceAttributes property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setKotlinNotNullInterfaceAttributes(Boolean value) { + this.kotlinNotNullInterfaceAttributes = value; + } + /** * Turn off generation of all global object references. * @@ -2784,6 +2862,21 @@ public class Generate implements Serializable, XMLAppendable return this; } + public Generate withKotlinNotNullPojoAttributes(Boolean value) { + setKotlinNotNullPojoAttributes(value); + return this; + } + + public Generate withKotlinNotNullRecordAttributes(Boolean value) { + setKotlinNotNullRecordAttributes(value); + return this; + } + + public Generate withKotlinNotNullInterfaceAttributes(Boolean value) { + setKotlinNotNullInterfaceAttributes(value); + return this; + } + public Generate withGlobalObjectReferences(Boolean value) { setGlobalObjectReferences(value); return this; @@ -3103,6 +3196,9 @@ public class Generate implements Serializable, XMLAppendable builder.append("springAnnotations", springAnnotations); builder.append("springDao", springDao); builder.append("kotlinSetterJvmNameAnnotationsOnIsPrefix", kotlinSetterJvmNameAnnotationsOnIsPrefix); + builder.append("kotlinNotNullPojoAttributes", kotlinNotNullPojoAttributes); + builder.append("kotlinNotNullRecordAttributes", kotlinNotNullRecordAttributes); + builder.append("kotlinNotNullInterfaceAttributes", kotlinNotNullInterfaceAttributes); builder.append("globalObjectReferences", globalObjectReferences); builder.append("globalCatalogReferences", globalCatalogReferences); builder.append("globalSchemaReferences", globalSchemaReferences); @@ -3621,6 +3717,33 @@ public class Generate implements Serializable, XMLAppendable return false; } } + if (kotlinNotNullPojoAttributes == null) { + if (other.kotlinNotNullPojoAttributes!= null) { + return false; + } + } else { + if (!kotlinNotNullPojoAttributes.equals(other.kotlinNotNullPojoAttributes)) { + return false; + } + } + if (kotlinNotNullRecordAttributes == null) { + if (other.kotlinNotNullRecordAttributes!= null) { + return false; + } + } else { + if (!kotlinNotNullRecordAttributes.equals(other.kotlinNotNullRecordAttributes)) { + return false; + } + } + if (kotlinNotNullInterfaceAttributes == null) { + if (other.kotlinNotNullInterfaceAttributes!= null) { + return false; + } + } else { + if (!kotlinNotNullInterfaceAttributes.equals(other.kotlinNotNullInterfaceAttributes)) { + return false; + } + } if (globalObjectReferences == null) { if (other.globalObjectReferences!= null) { return false; @@ -4101,6 +4224,9 @@ public class Generate implements Serializable, XMLAppendable result = ((prime*result)+((springAnnotations == null)? 0 :springAnnotations.hashCode())); result = ((prime*result)+((springDao == null)? 0 :springDao.hashCode())); result = ((prime*result)+((kotlinSetterJvmNameAnnotationsOnIsPrefix == null)? 0 :kotlinSetterJvmNameAnnotationsOnIsPrefix.hashCode())); + result = ((prime*result)+((kotlinNotNullPojoAttributes == null)? 0 :kotlinNotNullPojoAttributes.hashCode())); + result = ((prime*result)+((kotlinNotNullRecordAttributes == null)? 0 :kotlinNotNullRecordAttributes.hashCode())); + result = ((prime*result)+((kotlinNotNullInterfaceAttributes == null)? 0 :kotlinNotNullInterfaceAttributes.hashCode())); result = ((prime*result)+((globalObjectReferences == null)? 0 :globalObjectReferences.hashCode())); result = ((prime*result)+((globalCatalogReferences == null)? 0 :globalCatalogReferences.hashCode())); result = ((prime*result)+((globalSchemaReferences == null)? 0 :globalSchemaReferences.hashCode())); diff --git a/jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.18.0.xsd b/jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.18.0.xsd index ab04d74551..d779d07659 100644 --- a/jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.18.0.xsd +++ b/jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.18.0.xsd @@ -2145,6 +2145,18 @@ jOOQ version used for source code.]]> setX() setters instead of setIsX() in byte code for mutable properties called isX.]]> + + + + + + + + + + + +