From 06f14b1f913308de96047a79c98f9ed4eb99d075 Mon Sep 17 00:00:00 2001 From: lukaseder Date: Tue, 9 Jan 2018 15:38:47 +0100 Subject: [PATCH] [#5703] Add option to disable code generation of comments --- .../java/org/jooq/util/AbstractGenerator.java | 154 +++++++ .../java/org/jooq/util/GenerationTool.java | 28 ++ .../main/java/org/jooq/util/Generator.java | 140 ++++++ .../java/org/jooq/util/JavaGenerator.java | 128 ++++-- .../main/java/org/jooq/util/XMLGenerator.java | 50 +- .../java/org/jooq/util/jaxb/Generate.java | 434 ++++++++++++++++++ .../resources/xsd/jooq-codegen-3.11.0.xsd | 56 +++ 7 files changed, 951 insertions(+), 39 deletions(-) diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/AbstractGenerator.java b/jOOQ-codegen/src/main/java/org/jooq/util/AbstractGenerator.java index 115b85352e..502faab962 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/util/AbstractGenerator.java +++ b/jOOQ-codegen/src/main/java/org/jooq/util/AbstractGenerator.java @@ -94,6 +94,20 @@ abstract class AbstractGenerator implements Generator { boolean generateGlobalQueueReferences = true; boolean generateGlobalLinkReferences = true; boolean generateGlobalKeyReferences = true; + boolean generateComments = true; + boolean generateCommentsOnAttributes = true; + boolean generateCommentsOnCatalogs = true; + boolean generateCommentsOnColumns = true; + boolean generateCommentsOnKeys = true; + boolean generateCommentsOnLinks = true; + boolean generateCommentsOnPackages = true; + boolean generateCommentsOnParameters = true; + boolean generateCommentsOnQueues = true; + boolean generateCommentsOnRoutines = true; + boolean generateCommentsOnSchemas = true; + boolean generateCommentsOnSequences = true; + boolean generateCommentsOnTables = true; + boolean generateCommentsOnUDTs = true; boolean generateFluentSetters = false; boolean generateJavaBeansGettersAndSetters = false; boolean generateVarargsSetters = true; @@ -556,6 +570,146 @@ abstract class AbstractGenerator implements Generator { this.generateKeys = keys; } + @Override + public boolean generateComments() { + return generateComments; + } + + @Override + public void setGenerateComments(boolean comments) { + this.generateComments = comments; + } + + @Override + public boolean generateCommentsOnAttributes() { + return generateComments() && generateCommentsOnAttributes; + } + + @Override + public void setGenerateCommentsOnAttributes(boolean commentsOnAttributes) { + this.generateCommentsOnAttributes = commentsOnAttributes; + } + + @Override + public boolean generateCommentsOnCatalogs() { + return generateComments() && generateCommentsOnCatalogs; + } + + @Override + public void setGenerateCommentsOnCatalogs(boolean commentsOnCatalogs) { + this.generateCommentsOnCatalogs = commentsOnCatalogs; + } + + @Override + public boolean generateCommentsOnColumns() { + return generateComments() && generateCommentsOnColumns; + } + + @Override + public void setGenerateCommentsOnColumns(boolean commentsOnColumns) { + this.generateCommentsOnColumns = commentsOnColumns; + } + + @Override + public boolean generateCommentsOnKeys() { + return generateComments() && generateCommentsOnKeys; + } + + @Override + public void setGenerateCommentsOnKeys(boolean commentsOnKeys) { + this.generateCommentsOnKeys = commentsOnKeys; + } + + @Override + public boolean generateCommentsOnLinks() { + return generateComments() && generateCommentsOnLinks; + } + + @Override + public void setGenerateCommentsOnLinks(boolean commentsOnLinks) { + this.generateCommentsOnLinks = commentsOnLinks; + } + + @Override + public boolean generateCommentsOnPackages() { + return generateComments() && generateCommentsOnPackages; + } + + @Override + public void setGenerateCommentsOnPackages(boolean commentsOnPackages) { + this.generateCommentsOnPackages = commentsOnPackages; + } + + @Override + public boolean generateCommentsOnParameters() { + return generateComments() && generateCommentsOnParameters; + } + + @Override + public void setGenerateCommentsOnParameters(boolean commentsOnParameters) { + this.generateCommentsOnParameters = commentsOnParameters; + } + + @Override + public boolean generateCommentsOnQueues() { + return generateComments() && generateCommentsOnQueues; + } + + @Override + public void setGenerateCommentsOnQueues(boolean commentsOnQueues) { + this.generateCommentsOnQueues = commentsOnQueues; + } + + @Override + public boolean generateCommentsOnRoutines() { + return generateComments() && generateCommentsOnRoutines; + } + + @Override + public void setGenerateCommentsOnRoutines(boolean commentsOnRoutines) { + this.generateCommentsOnRoutines = commentsOnRoutines; + } + + @Override + public boolean generateCommentsOnSchemas() { + return generateComments() && generateCommentsOnSchemas; + } + + @Override + public void setGenerateCommentsOnSchemas(boolean commentsOnSchemas) { + this.generateCommentsOnSchemas = commentsOnSchemas; + } + + @Override + public boolean generateCommentsOnSequences() { + return generateComments() && generateCommentsOnSequences; + } + + @Override + public void setGenerateCommentsOnSequences(boolean commentsOnSequences) { + this.generateCommentsOnSequences = commentsOnSequences; + } + + @Override + public boolean generateCommentsOnTables() { + return generateComments() && generateCommentsOnTables; + } + + @Override + public void setGenerateCommentsOnTables(boolean commentsOnTables) { + this.generateCommentsOnTables = commentsOnTables; + } + + @Override + public boolean generateCommentsOnUDTs() { + return generateComments() && generateCommentsOnUDTs; + } + + @Override + public void setGenerateCommentsOnUDTs(boolean commentsOnUDTs) { + this.generateCommentsOnUDTs = commentsOnUDTs; + } + @Override @Deprecated public boolean fluentSetters() { diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java b/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java index 628a8fb1bb..ce2b861bee 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java +++ b/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java @@ -642,6 +642,34 @@ public class GenerationTool { generator.setGenerateGlobalLinkReferences(g.getGenerate().isGlobalLinkReferences()); if (g.getGenerate().isGlobalKeyReferences() != null) generator.setGenerateGlobalKeyReferences(g.getGenerate().isGlobalKeyReferences()); + if (g.getGenerate().isComments() != null) + generator.setGenerateComments(g.getGenerate().isComments()); + if (g.getGenerate().isCommentsOnAttributes() != null) + generator.setGenerateCommentsOnAttributes(g.getGenerate().isCommentsOnAttributes()); + if (g.getGenerate().isCommentsOnCatalogs() != null) + generator.setGenerateCommentsOnCatalogs(g.getGenerate().isCommentsOnCatalogs()); + if (g.getGenerate().isCommentsOnColumns() != null) + generator.setGenerateCommentsOnColumns(g.getGenerate().isCommentsOnColumns()); + if (g.getGenerate().isCommentsOnKeys() != null) + generator.setGenerateCommentsOnKeys(g.getGenerate().isCommentsOnKeys()); + if (g.getGenerate().isCommentsOnLinks() != null) + generator.setGenerateCommentsOnLinks(g.getGenerate().isCommentsOnLinks()); + if (g.getGenerate().isCommentsOnPackages() != null) + generator.setGenerateCommentsOnPackages(g.getGenerate().isCommentsOnPackages()); + if (g.getGenerate().isCommentsOnParameters() != null) + generator.setGenerateCommentsOnParameters(g.getGenerate().isCommentsOnParameters()); + if (g.getGenerate().isCommentsOnQueues() != null) + generator.setGenerateCommentsOnQueues(g.getGenerate().isCommentsOnQueues()); + if (g.getGenerate().isCommentsOnRoutines() != null) + generator.setGenerateCommentsOnRoutines(g.getGenerate().isCommentsOnRoutines()); + if (g.getGenerate().isCommentsOnSchemas() != null) + generator.setGenerateCommentsOnSchemas(g.getGenerate().isCommentsOnSchemas()); + if (g.getGenerate().isCommentsOnSequences() != null) + generator.setGenerateCommentsOnSequences(g.getGenerate().isCommentsOnSequences()); + if (g.getGenerate().isCommentsOnTables() != null) + generator.setGenerateCommentsOnTables(g.getGenerate().isCommentsOnTables()); + if (g.getGenerate().isCommentsOnUDTs() != null) + generator.setGenerateCommentsOnUDTs(g.getGenerate().isCommentsOnUDTs()); if (g.getGenerate().isFluentSetters() != null) generator.setGenerateFluentSetters(g.getGenerate().isFluentSetters()); if (g.getGenerate().isJavaBeansGettersAndSetters() != null) diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/Generator.java b/jOOQ-codegen/src/main/java/org/jooq/util/Generator.java index f33331f158..7a37368be8 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/util/Generator.java +++ b/jOOQ-codegen/src/main/java/org/jooq/util/Generator.java @@ -393,6 +393,146 @@ public interface Generator { */ void setGenerateGlobalKeyReferences(boolean globalKeyReferences); + /** + * Whether any SQL comments should be generated as Javadoc. + */ + boolean generateComments(); + + /** + * Whether any SQL comments should be generated as Javadoc. + */ + void setGenerateComments(boolean comments); + + /** + * Whether SQL comments on attributes should be generated as Javadoc. + */ + boolean generateCommentsOnAttributes(); + + /** + * Whether SQL comments on attributes should be generated as Javadoc. + */ + void setGenerateCommentsOnAttributes(boolean commentsOnAttributes); + + /** + * Whether SQL comments on catalogs should be generated as Javadoc. + */ + boolean generateCommentsOnCatalogs(); + + /** + * Whether SQL comments on catalogs should be generated as Javadoc. + */ + void setGenerateCommentsOnCatalogs(boolean commentsOnCatalogs); + + /** + * Whether SQL comments on columns should be generated as Javadoc. + */ + boolean generateCommentsOnColumns(); + + /** + * Whether SQL comments on columns should be generated as Javadoc. + */ + void setGenerateCommentsOnColumns(boolean commentsOnColumns); + + /** + * Whether SQL comments on keys should be generated as Javadoc. + */ + boolean generateCommentsOnKeys(); + + /** + * Whether SQL comments on keys should be generated as Javadoc. + */ + void setGenerateCommentsOnKeys(boolean commentsOnKeys); + + /** + * Whether SQL comments on links should be generated as Javadoc. + */ + boolean generateCommentsOnLinks(); + + /** + * Whether SQL comments on links should be generated as Javadoc. + */ + void setGenerateCommentsOnLinks(boolean commentsOnLinks); + + /** + * Whether SQL comments on packages should be generated as Javadoc. + */ + boolean generateCommentsOnPackages(); + + /** + * Whether SQL comments on packages should be generated as Javadoc. + */ + void setGenerateCommentsOnPackages(boolean commentsOnPackages); + + /** + * Whether SQL comments on parameters should be generated as Javadoc. + */ + boolean generateCommentsOnParameters(); + + /** + * Whether SQL comments on parameters should be generated as Javadoc. + */ + void setGenerateCommentsOnParameters(boolean commentsOnParameters); + + /** + * Whether SQL comments on queues should be generated as Javadoc. + */ + boolean generateCommentsOnQueues(); + + /** + * Whether SQL comments on queues should be generated as Javadoc. + */ + void setGenerateCommentsOnQueues(boolean commentsOnQueues); + + /** + * Whether SQL comments on routines should be generated as Javadoc. + */ + boolean generateCommentsOnRoutines(); + + /** + * Whether SQL comments on routines should be generated as Javadoc. + */ + void setGenerateCommentsOnRoutines(boolean commentsOnRoutines); + + /** + * Whether SQL comments on schemas should be generated as Javadoc. + */ + boolean generateCommentsOnSchemas(); + + /** + * Whether SQL comments on schemas should be generated as Javadoc. + */ + void setGenerateCommentsOnSchemas(boolean commentsOnSchemas); + + /** + * Whether SQL comments on sequences should be generated as Javadoc. + */ + boolean generateCommentsOnSequences(); + + /** + * Whether SQL comments on sequences should be generated as Javadoc. + */ + void setGenerateCommentsOnSequences(boolean commentsOnSequences); + + /** + * Whether SQL comments on tables should be generated as Javadoc. + */ + boolean generateCommentsOnTables(); + + /** + * Whether SQL comments on tables should be generated as Javadoc. + */ + void setGenerateCommentsOnTables(boolean commentsOnTables); + + /** + * Whether SQL comments on UDTs should be generated as Javadoc. + */ + boolean generateCommentsOnUDTs(); + + /** + * Whether SQL comments on UDTs should be generated as Javadoc. + */ + void setGenerateCommentsOnUDTs(boolean commentsOnUDTs); + /** * Whether queue related code should be generated */ diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java b/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java index 2df1b1e37c..992967e556 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java +++ b/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java @@ -278,6 +278,20 @@ public class JavaGenerator extends AbstractGenerator { log.info(" annotations (JPA: any)", generateJPAAnnotations()); log.info(" annotations (JPA: version)", generateJPAVersion()); log.info(" annotations (validation)", generateValidationAnnotations()); + log.info(" comments", generateComments()); + log.info(" comments on attributes", generateCommentsOnAttributes()); + log.info(" comments on catalogs", generateCommentsOnCatalogs()); + log.info(" comments on columns", generateCommentsOnColumns()); + log.info(" comments on keys", generateCommentsOnKeys()); + log.info(" comments on links", generateCommentsOnLinks()); + log.info(" comments on packages", generateCommentsOnPackages()); + log.info(" comments on parameters", generateCommentsOnParameters()); + log.info(" comments on queues", generateCommentsOnQueues()); + log.info(" comments on routines", generateCommentsOnRoutines()); + log.info(" comments on schemas", generateCommentsOnSchemas()); + log.info(" comments on sequences", generateCommentsOnSequences()); + log.info(" comments on tables", generateCommentsOnTables()); + log.info(" comments on udts", generateCommentsOnUDTs()); log.info(" daos", generateDaos()); log.info(" deprecated code", generateDeprecated()); log.info(" global references (any)", generateGlobalObjectReferences()); @@ -1489,7 +1503,7 @@ public class JavaGenerator extends AbstractGenerator { // We cannot have covariant setters for arrays because of type erasure if (!(generateInterfaces() && isArray)) { if (!printDeprecationIfUnknownType(out, typeFull)) - out.tab(1).javadoc("Setter for %s.%s", name, defaultIfBlank(" " + escapeEntities(comment), "")); + out.tab(1).javadoc("Setter for %s.%s", name, columnComment(column, comment)); if (scala) { out.tab(1).println("def %s(value : %s) : %s = {", setter, type, setterReturnType); @@ -1590,7 +1604,7 @@ public class JavaGenerator extends AbstractGenerator { final String name = column.getQualifiedOutputName(); if (!printDeprecationIfUnknownType(out, typeFull)) - out.tab(1).javadoc("Getter for %s.%s", name, defaultIfBlank(" " + escapeEntities(comment), "")); + out.tab(1).javadoc("Getter for %s.%s", name, columnComment(column, comment)); if (column.getContainer() instanceof TableDefinition) printColumnJPAAnnotation(out, (ColumnDefinition) column); @@ -1636,7 +1650,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateRecordClassJavadoc(TableDefinition table, JavaWriter out) { - printClassJavadoc(out, table); + if (generateCommentsOnTables()) + printClassJavadoc(out, table); + else + printClassJavadoc(out, "The table " + table.getQualifiedInputName() + "."); } private String refRowType(JavaWriter out, Collection> columns) { @@ -1779,7 +1796,7 @@ public class JavaGenerator extends AbstractGenerator { final String name = column.getQualifiedOutputName(); if (!printDeprecationIfUnknownType(out, typeFull)) - out.tab(1).javadoc("Setter for %s.%s", name, defaultIfBlank(" " + escapeEntities(comment), "")); + out.tab(1).javadoc("Setter for %s.%s", name, columnComment(column, comment)); if (scala) out.tab(1).println("def %s(value : %s) : %s", setter, type, setterReturnType); @@ -1809,7 +1826,7 @@ public class JavaGenerator extends AbstractGenerator { final String name = column.getQualifiedOutputName(); if (!printDeprecationIfUnknownType(out, typeFull)) - out.tab(1).javadoc("Getter for %s.%s", name, defaultIfBlank(" " + escapeEntities(comment), "")); + out.tab(1).javadoc("Getter for %s.%s", name, columnComment(column, comment)); if (column instanceof ColumnDefinition) printColumnJPAAnnotation(out, (ColumnDefinition) column); @@ -1822,6 +1839,19 @@ public class JavaGenerator extends AbstractGenerator { out.tab(1).println("public %s %s();", type, getter); } + private String columnComment(TypedElementDefinition column, String comment) { + return column instanceof ColumnDefinition && generateCommentsOnColumns() + || column instanceof AttributeDefinition && generateCommentsOnAttributes() + ? defaultIfBlank(" " + escapeEntities(comment), "") + : ""; + } + + private String parameterComment(String comment) { + return generateCommentsOnParameters() + ? defaultIfBlank(" " + escapeEntities(comment), "") + : ""; + } + /** * Subclasses may override this method to provide interface class footer * code. @@ -1833,7 +1863,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateInterfaceClassJavadoc(TableDefinition table, JavaWriter out) { - printClassJavadoc(out, table); + if (generateCommentsOnTables()) + printClassJavadoc(out, table); + else + printClassJavadoc(out, "The table " + table.getQualifiedInputName() + "."); } protected void generateUDTs(SchemaDefinition schema) { @@ -1879,7 +1912,7 @@ public class JavaGenerator extends AbstractGenerator { final String attrId = out.ref(getStrategy().getJavaIdentifier(attribute), 2); final String attrComment = StringUtils.defaultString(attribute.getComment()); - out.tab(1).javadoc("The attribute %s.%s", attribute.getQualifiedOutputName(), defaultIfBlank(" " + escapeEntities(attrComment), "")); + out.tab(1).javadoc("The attribute %s.%s", attribute.getQualifiedOutputName(), columnComment(attribute, attrComment)); out.tab(1).println("val %s = %s.%s", attrId, udtId, attrId); } @@ -1923,7 +1956,7 @@ public class JavaGenerator extends AbstractGenerator { } else { if (!printDeprecationIfUnknownType(out, attrTypeFull)) - out.tab(1).javadoc("The attribute %s.%s", attribute.getQualifiedOutputName(), defaultIfBlank(" " + attrComment, "")); + out.tab(1).javadoc("The attribute %s.%s", attribute.getQualifiedOutputName(), columnComment(attribute, attrComment)); out.tab(1).println("public static final %s<%s, %s> %s = createField(\"%s\", %s, %s, \"%s\"" + converterTemplate(converter) + converterTemplate(binding) + ");", UDTField.class, recordType, attrType, attrId, attrName, attrTypeRef, udtId, escapeString(""), converter, binding); @@ -1990,7 +2023,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateUDTClassJavadoc(UDTDefinition udt, JavaWriter out) { - printClassJavadoc(out, udt); + if (generateCommentsOnUDTs()) + printClassJavadoc(out, udt); + else + printClassJavadoc(out, "The udt " + udt.getQualifiedInputName() + "."); } protected void generateUDTPojos(SchemaDefinition schema) { @@ -2018,7 +2054,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateUDTPojoClassJavadoc(UDTDefinition udt, JavaWriter out) { - printClassJavadoc(out, udt); + if (generateCommentsOnUDTs()) + printClassJavadoc(out, udt); + else + printClassJavadoc(out, "The udt " + udt.getQualifiedInputName() + "."); } protected void generateUDTInterfaces(SchemaDefinition schema) { @@ -2045,7 +2084,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateUDTInterfaceClassJavadoc(UDTDefinition udt, JavaWriter out) { - printClassJavadoc(out, udt); + if (generateCommentsOnUDTs()) + printClassJavadoc(out, udt); + else + printClassJavadoc(out, "The udt " + udt.getQualifiedInputName() + "."); } /** @@ -2075,7 +2117,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateUDTRecordClassJavadoc(UDTDefinition udt, JavaWriter out) { - printClassJavadoc(out, udt); + if (generateCommentsOnUDTs()) + printClassJavadoc(out, udt); + else + printClassJavadoc(out, "The udt " + udt.getQualifiedInputName() + "."); } protected void generateUDTRoutines(SchemaDefinition schema) { @@ -2267,7 +2312,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateArrayClassJavadoc(ArrayDefinition array, JavaWriter out) { - printClassJavadoc(out, array); + if (generateCommentsOnUDTs()) + printClassJavadoc(out, array); + else + printClassJavadoc(out, "The type " + array.getQualifiedInputName() + "."); } protected void generateEnums(SchemaDefinition schema) { @@ -2447,7 +2495,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateEnumClassJavadoc(EnumDefinition e, JavaWriter out) { - printClassJavadoc(out, e); + if (generateCommentsOnUDTs()) + printClassJavadoc(out, e); + else + printClassJavadoc(out, "The enum " + e.getQualifiedInputName() + "."); } protected void generateDomain(DomainDefinition d) { @@ -2489,7 +2540,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateDomainClassJavadoc(DomainDefinition e, JavaWriter out) { - printClassJavadoc(out, e); + if (generateCommentsOnUDTs()) + printClassJavadoc(out, e); + else + printClassJavadoc(out, "The domain " + e.getQualifiedInputName() + "."); } protected void generateRoutines(SchemaDefinition schema) { @@ -2700,7 +2754,7 @@ public class JavaGenerator extends AbstractGenerator { final String className = out.ref(getStrategy().getFullJavaClassName(table)); final String id = getStrategy().getJavaIdentifier(table); final String fullId = getStrategy().getFullJavaIdentifier(table); - final String comment = !StringUtils.isBlank(table.getComment()) + final String comment = !StringUtils.isBlank(table.getComment()) && generateCommentsOnTables() ? escapeEntities(table.getComment()) : "The table " + table.getQualifiedOutputName() + "."; @@ -2938,7 +2992,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateDaoClassJavadoc(TableDefinition table, JavaWriter out) { - printClassJavadoc(out, table); + if (generateCommentsOnTables()) + printClassJavadoc(out, table); + else + printClassJavadoc(out, "The table " + table.getQualifiedInputName() + "."); } protected void generatePojos(SchemaDefinition schema) { @@ -3514,7 +3571,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generatePojoClassJavadoc(TableDefinition table, JavaWriter out) { - printClassJavadoc(out, table); + if (generateCommentsOnTables()) + printClassJavadoc(out, table); + else + printClassJavadoc(out, "The table " + table.getQualifiedInputName() + "."); } protected void generateTables(SchemaDefinition schema) { @@ -3595,7 +3655,7 @@ public class JavaGenerator extends AbstractGenerator { final List binding = out.ref(list(column.getType(resolver()).getBinding())); if (!printDeprecationIfUnknownType(out, columnTypeFull)) - out.tab(1).javadoc("The column %s.%s", column.getQualifiedOutputName(), defaultIfBlank(" " + escapeEntities(columnComment), "")); + out.tab(1).javadoc("The column %s.%s", column.getQualifiedOutputName(), columnComment(column, columnComment)); if (scala) { out.tab(1).println("val %s : %s[%s, %s] = createField(\"%s\", %s, \"%s\"" + converterTemplate(converter) + converterTemplate(binding) + ")", @@ -4085,7 +4145,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateTableClassJavadoc(TableDefinition table, JavaWriter out) { - printClassJavadoc(out, table); + if (generateCommentsOnTables()) + printClassJavadoc(out, table); + else + printClassJavadoc(out, "The table " + table.getQualifiedInputName() + "."); } protected void generateSequences(SchemaDefinition schema) { @@ -4171,7 +4234,7 @@ public class JavaGenerator extends AbstractGenerator { final String schemaClassName = out.ref(getStrategy().getFullJavaClassName(schema)); final String schemaId = getStrategy().getJavaIdentifier(schema); final String schemaFullId = getStrategy().getFullJavaIdentifier(schema); - final String schemaComment = !StringUtils.isBlank(schema.getComment()) + final String schemaComment = !StringUtils.isBlank(schema.getComment()) && generateCommentsOnSchemas() ? escapeEntities(schema.getComment()) : "The schema " + schema.getQualifiedOutputName() + "."; @@ -4209,8 +4272,11 @@ public class JavaGenerator extends AbstractGenerator { /** * Subclasses may override this method to provide their own Javadoc. */ - protected void generateCatalogClassJavadoc(CatalogDefinition schema, JavaWriter out) { - printClassJavadoc(out, schema); + protected void generateCatalogClassJavadoc(CatalogDefinition catalog, JavaWriter out) { + if (generateCommentsOnCatalogs()) + printClassJavadoc(out, catalog); + else + printClassJavadoc(out, "The catalog " + catalog.getQualifiedInputName() + "."); } protected void generateSchema(SchemaDefinition schema) { @@ -4255,7 +4321,7 @@ public class JavaGenerator extends AbstractGenerator { final String tableClassName = out.ref(getStrategy().getFullJavaClassName(table)); final String tableId = getStrategy().getJavaIdentifier(table); final String tableFullId = getStrategy().getFullJavaIdentifier(table); - final String tableComment = !StringUtils.isBlank(table.getComment()) + final String tableComment = !StringUtils.isBlank(table.getComment()) && generateCommentsOnTables() ? escapeEntities(table.getComment()) : "The table " + table.getQualifiedOutputName() + "."; @@ -4314,7 +4380,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateSchemaClassJavadoc(SchemaDefinition schema, JavaWriter out) { - printClassJavadoc(out, schema); + if (generateCommentsOnSchemas()) + printClassJavadoc(out, schema); + else + printClassJavadoc(out, "The schema " + schema.getQualifiedInputName() + "."); } protected void printFromAndInto(JavaWriter out, TableDefinition table) { @@ -4666,7 +4735,7 @@ public class JavaGenerator extends AbstractGenerator { )); if (!printDeprecationIfUnknownType(out, paramTypeFull)) - out.tab(1).javadoc("The parameter %s.%s", parameter.getQualifiedOutputName(), defaultIfBlank(" " + escapeEntities(paramComment), "")); + out.tab(1).javadoc("The parameter %s.%s", parameter.getQualifiedOutputName(), parameterComment(paramComment)); out.tab(1).println("val %s : %s[%s] = %s.createParameter(\"%s\", %s, %s, %s[[before=, ][new %s]])", paramId, Parameter.class, paramType, AbstractRoutine.class, paramName, paramTypeRef, isDefaulted, isUnnamed, converters); @@ -4703,7 +4772,7 @@ public class JavaGenerator extends AbstractGenerator { final List binding = out.ref(list(parameter.getType(resolver()).getBinding())); if (!printDeprecationIfUnknownType(out, paramTypeFull)) - out.tab(1).javadoc("The parameter %s.%s", parameter.getQualifiedOutputName(), defaultIfBlank(" " + paramComment, "")); + out.tab(1).javadoc("The parameter %s.%s", parameter.getQualifiedOutputName(), parameterComment(paramComment)); out.tab(1).println("public static final %s<%s> %s = createParameter(\"%s\", %s, %s, %s" + converterTemplate(converter) + converterTemplate(binding) + ");", Parameter.class, paramType, paramId, paramName, paramTypeRef, isDefaulted, isUnnamed, converter, binding); @@ -4867,7 +4936,10 @@ public class JavaGenerator extends AbstractGenerator { * Subclasses may override this method to provide their own Javadoc. */ protected void generateRoutineClassJavadoc(RoutineDefinition routine, JavaWriter out) { - printClassJavadoc(out, routine); + if (generateCommentsOnRoutines()) + printClassJavadoc(out, routine); + else + printClassJavadoc(out, "The routine " + routine.getQualifiedInputName() + "."); } protected void printConvenienceMethodFunctionAsField(JavaWriter out, RoutineDefinition function, boolean parametersAsField) { diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/XMLGenerator.java b/jOOQ-codegen/src/main/java/org/jooq/util/XMLGenerator.java index ce64d8944c..a470533a1d 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/util/XMLGenerator.java +++ b/jOOQ-codegen/src/main/java/org/jooq/util/XMLGenerator.java @@ -106,7 +106,9 @@ public class XMLGenerator extends AbstractGenerator { String catalogName = c.getOutputName(); if (hasNonDefaultCatalogs) - is.getCatalogs().add(new Catalog().withCatalogName(catalogName).withComment(c.getComment())); + is.getCatalogs().add(new Catalog() + .withCatalogName(catalogName) + .withComment(generateCommentsOnCatalogs() ? c.getComment() : null)); for (SchemaDefinition s : c.getSchemata()) { String schemaName = s.getOutputName(); @@ -114,7 +116,9 @@ public class XMLGenerator extends AbstractGenerator { Schema schema = new Schema(); schema.setCatalogName(catalogName); schema.setSchemaName(schemaName); - schema.setComment(s.getComment()); + + if (generateCommentsOnSchemas()) + schema.setComment(s.getComment()); is.getSchemata().add(schema); @@ -125,7 +129,9 @@ public class XMLGenerator extends AbstractGenerator { table.setTableCatalog(catalogName); table.setTableSchema(schemaName); table.setTableName(tableName); - table.setComment(t.getComment()); + + if (generateCommentsOnTables()) + table.setComment(t.getComment()); is.getTables().add(table); @@ -138,7 +144,10 @@ public class XMLGenerator extends AbstractGenerator { column.setTableSchema(schemaName); column.setTableName(tableName); column.setColumnName(columnName); - column.setComment(co.getComment()); + + if (generateCommentsOnColumns()) + column.setComment(co.getComment()); + column.setCharacterMaximumLength(type.getLength()); column.setColumnDefault(type.getDefaultValue()); column.setDataType(type.getType()); @@ -162,7 +171,10 @@ public class XMLGenerator extends AbstractGenerator { index.setIndexCatalog(catalogName); index.setIndexSchema(schemaName); index.setIndexName(indexName); - index.setComment(i.getComment()); + + if (generateCommentsOnKeys()) + index.setComment(i.getComment()); + index.setTableCatalog(table.getCatalog().getOutputName()); index.setTableSchema(table.getSchema().getOutputName()); index.setTableName(table.getOutputName()); @@ -199,7 +211,10 @@ public class XMLGenerator extends AbstractGenerator { constraint.setConstraintSchema(schemaName); constraint.setConstraintName(constraintName); constraint.setConstraintType(u.isPrimaryKey() ? PRIMARY_KEY : UNIQUE); - constraint.setComment(u.getComment()); + + if (generateCommentsOnKeys()) + constraint.setComment(u.getComment()); + constraint.setTableCatalog(table.getCatalog().getOutputName()); constraint.setTableSchema(table.getSchema().getOutputName()); constraint.setTableName(table.getOutputName()); @@ -235,7 +250,10 @@ public class XMLGenerator extends AbstractGenerator { tc.setConstraintSchema(schemaName); tc.setConstraintName(constraintName); tc.setConstraintType(FOREIGN_KEY); - tc.setComment(f.getComment()); + + if (generateCommentsOnKeys()) + tc.setComment(f.getComment()); + tc.setTableCatalog(table.getCatalog().getOutputName()); tc.setTableSchema(table.getSchema().getOutputName()); tc.setTableName(table.getOutputName()); @@ -278,7 +296,10 @@ public class XMLGenerator extends AbstractGenerator { constraint.setConstraintSchema(schemaName); constraint.setConstraintName(constraintName); constraint.setConstraintType(CHECK); - constraint.setComment(ch.getComment()); + + if (generateCommentsOnKeys()) + constraint.setComment(ch.getComment()); + constraint.setTableCatalog(table.getCatalog().getOutputName()); constraint.setTableSchema(table.getSchema().getOutputName()); constraint.setTableName(table.getOutputName()); @@ -294,7 +315,10 @@ public class XMLGenerator extends AbstractGenerator { sequence.setSequenceCatalog(catalogName); sequence.setSequenceSchema(schemaName); sequence.setSequenceName(sequenceName); - sequence.setComment(se.getComment()); + + if (generateCommentsOnSequences()) + sequence.setComment(se.getComment()); + sequence.setCharacterMaximumLength(type.getLength()); sequence.setDataType(type.getType()); sequence.setNumericPrecision(type.getPrecision()); @@ -334,7 +358,9 @@ public class XMLGenerator extends AbstractGenerator { routine.setRoutineName(r.getName()); routine.setSpecificName(specificName); - routine.setComment(r.getComment()); + + if (generateCommentsOnRoutines()) + routine.setComment(r.getComment()); if (r.getReturnValue() == null) { routine.setRoutineType(RoutineType.PROCEDURE); @@ -363,7 +389,9 @@ public class XMLGenerator extends AbstractGenerator { parameter.setSpecificName(specificName); parameter.setOrdinalPosition(i++); parameter.setParameterName(p.getName()); - parameter.setComment(p.getComment()); + + if (generateCommentsOnParameters()) + parameter.setComment(p.getComment()); boolean in = r.getInParameters().contains(p); boolean out = r.getOutParameters().contains(p); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/jaxb/Generate.java b/jOOQ-meta/src/main/java/org/jooq/util/jaxb/Generate.java index 531904c9f1..1adda9ff59 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/jaxb/Generate.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/jaxb/Generate.java @@ -106,6 +106,34 @@ public class Generate implements Serializable protected Boolean globalLinkReferences = true; @XmlElement(defaultValue = "true") protected Boolean globalKeyReferences = true; + @XmlElement(defaultValue = "true") + protected Boolean comments = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnCatalogs = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnSchemas = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnTables = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnColumns = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnUDTs = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnAttributes = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnPackages = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnRoutines = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnParameters = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnSequences = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnLinks = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnQueues = true; + @XmlElement(defaultValue = "true") + protected Boolean commentsOnKeys = true; @XmlElement(defaultValue = "false") protected Boolean fluentSetters = false; @XmlElement(defaultValue = "false") @@ -992,6 +1020,342 @@ public class Generate implements Serializable this.globalKeyReferences = value; } + /** + * Turn off generation of all SQL comments as Javadoc on all objects. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isComments() { + return comments; + } + + /** + * Sets the value of the comments property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setComments(Boolean value) { + this.comments = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all catalogs. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnCatalogs() { + return commentsOnCatalogs; + } + + /** + * Sets the value of the commentsOnCatalogs property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnCatalogs(Boolean value) { + this.commentsOnCatalogs = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all schemas. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnSchemas() { + return commentsOnSchemas; + } + + /** + * Sets the value of the commentsOnSchemas property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnSchemas(Boolean value) { + this.commentsOnSchemas = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all tables. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnTables() { + return commentsOnTables; + } + + /** + * Sets the value of the commentsOnTables property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnTables(Boolean value) { + this.commentsOnTables = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all columns. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnColumns() { + return commentsOnColumns; + } + + /** + * Sets the value of the commentsOnColumns property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnColumns(Boolean value) { + this.commentsOnColumns = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all UDTs. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnUDTs() { + return commentsOnUDTs; + } + + /** + * Sets the value of the commentsOnUDTs property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnUDTs(Boolean value) { + this.commentsOnUDTs = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all attributes. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnAttributes() { + return commentsOnAttributes; + } + + /** + * Sets the value of the commentsOnAttributes property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnAttributes(Boolean value) { + this.commentsOnAttributes = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all packages. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnPackages() { + return commentsOnPackages; + } + + /** + * Sets the value of the commentsOnPackages property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnPackages(Boolean value) { + this.commentsOnPackages = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all routines. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnRoutines() { + return commentsOnRoutines; + } + + /** + * Sets the value of the commentsOnRoutines property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnRoutines(Boolean value) { + this.commentsOnRoutines = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all parameters. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnParameters() { + return commentsOnParameters; + } + + /** + * Sets the value of the commentsOnParameters property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnParameters(Boolean value) { + this.commentsOnParameters = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all sequences. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnSequences() { + return commentsOnSequences; + } + + /** + * Sets the value of the commentsOnSequences property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnSequences(Boolean value) { + this.commentsOnSequences = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all links. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnLinks() { + return commentsOnLinks; + } + + /** + * Sets the value of the commentsOnLinks property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnLinks(Boolean value) { + this.commentsOnLinks = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all queues. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnQueues() { + return commentsOnQueues; + } + + /** + * Sets the value of the commentsOnQueues property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnQueues(Boolean value) { + this.commentsOnQueues = value; + } + + /** + * Turn off generation of all SQL comments as Javadoc on all keys. + * + * @return + * possible object is + * {@link Boolean } + * + */ + public Boolean isCommentsOnKeys() { + return commentsOnKeys; + } + + /** + * Sets the value of the commentsOnKeys property. + * + * @param value + * allowed object is + * {@link Boolean } + * + */ + public void setCommentsOnKeys(Boolean value) { + this.commentsOnKeys = value; + } + /** * Generate fluent setters in records, POJOs, interfaces. * @@ -1390,6 +1754,76 @@ public class Generate implements Serializable return this; } + public Generate withComments(Boolean value) { + setComments(value); + return this; + } + + public Generate withCommentsOnCatalogs(Boolean value) { + setCommentsOnCatalogs(value); + return this; + } + + public Generate withCommentsOnSchemas(Boolean value) { + setCommentsOnSchemas(value); + return this; + } + + public Generate withCommentsOnTables(Boolean value) { + setCommentsOnTables(value); + return this; + } + + public Generate withCommentsOnColumns(Boolean value) { + setCommentsOnColumns(value); + return this; + } + + public Generate withCommentsOnUDTs(Boolean value) { + setCommentsOnUDTs(value); + return this; + } + + public Generate withCommentsOnAttributes(Boolean value) { + setCommentsOnAttributes(value); + return this; + } + + public Generate withCommentsOnPackages(Boolean value) { + setCommentsOnPackages(value); + return this; + } + + public Generate withCommentsOnRoutines(Boolean value) { + setCommentsOnRoutines(value); + return this; + } + + public Generate withCommentsOnParameters(Boolean value) { + setCommentsOnParameters(value); + return this; + } + + public Generate withCommentsOnSequences(Boolean value) { + setCommentsOnSequences(value); + return this; + } + + public Generate withCommentsOnLinks(Boolean value) { + setCommentsOnLinks(value); + return this; + } + + public Generate withCommentsOnQueues(Boolean value) { + setCommentsOnQueues(value); + return this; + } + + public Generate withCommentsOnKeys(Boolean value) { + setCommentsOnKeys(value); + return this; + } + public Generate withFluentSetters(Boolean value) { setFluentSetters(value); return this; diff --git a/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.11.0.xsd b/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.11.0.xsd index abaad070fe..f1dd7e8c82 100644 --- a/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.11.0.xsd +++ b/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.11.0.xsd @@ -968,6 +968,62 @@ jOOQ version used for source code]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +