From a12ce0fe6899b879e5836032e939ccacc994c5a9 Mon Sep 17 00:00:00 2001 From: lukaseder Date: Wed, 23 Mar 2016 19:28:00 +0100 Subject: [PATCH] [#3482] Add flags to the code generator to turn on / off generation for tables, views, packages, procedures, udts, etc. --- .../java/org/jooq/util/GenerationTool.java | 9 + .../java/org/jooq/util/AbstractDatabase.java | 265 ++++++++++++------ .../src/main/java/org/jooq/util/Database.java | 80 ++++++ .../main/resources/xsd/jooq-codegen-3.8.0.xsd | 9 + 4 files changed, 281 insertions(+), 82 deletions(-) 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 1441ea99ed..cad4e4727f 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java +++ b/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java @@ -40,6 +40,7 @@ */ package org.jooq.util; +import static java.lang.Boolean.FALSE; import static java.lang.Boolean.TRUE; import static org.jooq.tools.StringUtils.defaultIfNull; import static org.jooq.tools.StringUtils.defaultString; @@ -336,6 +337,14 @@ public class GenerationTool { database.setIncludes(new String[] { defaultString(d.getIncludes()) }); database.setExcludes(new String[] { defaultString(d.getExcludes()) }); database.setIncludeExcludeColumns(TRUE.equals(d.isIncludeExcludeColumns())); + database.setIncludeForeignKeys(!FALSE.equals(d.isIncludeForeignKeys())); + database.setIncludePackages(!FALSE.equals(d.isIncludePackages())); + database.setIncludePrimaryKeys(!FALSE.equals(d.isIncludePrimaryKeys())); + database.setIncludeRoutines(!FALSE.equals(d.isIncludeRoutines())); + database.setIncludeSequences(!FALSE.equals(d.isIncludeSequences())); + database.setIncludeTables(!FALSE.equals(d.isIncludeTables())); + database.setIncludeUDTs(!FALSE.equals(d.isIncludeUDTs())); + database.setIncludeUniqueKeys(!FALSE.equals(d.isIncludeUniqueKeys())); database.setRecordVersionFields(new String[] { defaultString(d.getRecordVersionFields()) }); database.setRecordTimestampFields(new String[] { defaultString(d.getRecordTimestampFields()) }); database.setSyntheticPrimaryKeys(new String[] { defaultString(d.getSyntheticPrimaryKeys()) }); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java index a989870415..fd5c062653 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java @@ -109,6 +109,14 @@ public abstract class AbstractDatabase implements Database { private String[] excludes; private String[] includes; private boolean includeExcludeColumns; + private boolean includeTables = true; + private boolean includeRoutines = true; + private boolean includePackages = true; + private boolean includeUDTs = true; + private boolean includeSequences = true; + private boolean includePrimaryKeys = true; + private boolean includeUniqueKeys = true; + private boolean includeForeignKeys = true; private String[] recordVersionFields; private String[] recordTimestampFields; private String[] syntheticPrimaryKeys; @@ -538,6 +546,86 @@ public abstract class AbstractDatabase implements Database { return includeExcludeColumns; } + @Override + public final boolean getIncludeTables() { + return includeTables; + } + + @Override + public final void setIncludeTables(boolean includeTables) { + this.includeTables = includeTables; + } + + @Override + public final boolean getIncludeRoutines() { + return includeRoutines; + } + + @Override + public final void setIncludeRoutines(boolean includeRoutines) { + this.includeRoutines = includeRoutines; + } + + @Override + public final boolean getIncludePackages() { + return includePackages; + } + + @Override + public final void setIncludePackages(boolean includePackages) { + this.includePackages = includePackages; + } + + @Override + public final boolean getIncludeUDTs() { + return includeUDTs; + } + + @Override + public final void setIncludeUDTs(boolean includeUDTs) { + this.includeUDTs = includeUDTs; + } + + @Override + public final boolean getIncludeSequences() { + return includeSequences; + } + + @Override + public final void setIncludeSequences(boolean includeSequences) { + this.includeSequences = includeSequences; + } + + @Override + public final boolean getIncludePrimaryKeys() { + return includePrimaryKeys; + } + + @Override + public final void setIncludePrimaryKeys(boolean includePrimaryKeys) { + this.includePrimaryKeys = includePrimaryKeys; + } + + @Override + public final boolean getIncludeUniqueKeys() { + return includeUniqueKeys; + } + + @Override + public final void setIncludeUniqueKeys(boolean includeUniqueKeys) { + this.includeUniqueKeys = includeUniqueKeys; + } + + @Override + public final boolean getIncludeForeignKeys() { + return includeForeignKeys; + } + + @Override + public final void setIncludeForeignKeys(boolean includeForeignKeys) { + this.includeForeignKeys = includeForeignKeys; + } + @Override public final void setRegexFlags(List regexFlags) { this.regexFlags = regexFlags; @@ -785,19 +873,23 @@ public abstract class AbstractDatabase implements Database { if (sequences == null) { sequences = new ArrayList(); - try { - List s = getSequences0(); + if (getIncludeSequences()) { + try { + List s = getSequences0(); - sequences = filterExcludeInclude(s); - log.info("Sequences fetched", fetchedSize(s, sequences)); - } catch (Exception e) { - log.error("Error while fetching sequences", e); + sequences = filterExcludeInclude(s); + log.info("Sequences fetched", fetchedSize(s, sequences)); + } + catch (Exception e) { + log.error("Error while fetching sequences", e); + } } + else + log.info("Sequences excluded"); } - if (sequencesBySchema == null) { + if (sequencesBySchema == null) sequencesBySchema = new LinkedHashMap>(); - } return filterSchema(sequences, schema, sequencesBySchema); } @@ -811,16 +903,14 @@ public abstract class AbstractDatabase implements Database { for (TableDefinition table : getTables(s)) { IdentityDefinition identity = table.getIdentity(); - if (identity != null) { + if (identity != null) identities.add(identity); - } } } } - if (identitiesBySchema == null) { + if (identitiesBySchema == null) identitiesBySchema = new LinkedHashMap>(); - } return filterSchema(identities, schema, identitiesBySchema); } @@ -832,18 +922,15 @@ public abstract class AbstractDatabase implements Database { if (uniqueKeys == null) { uniqueKeys = new ArrayList(); - for (SchemaDefinition s : getSchemata()) { - for (TableDefinition table : getTables(s)) { - for (UniqueKeyDefinition uniqueKey : table.getUniqueKeys()) { - uniqueKeys.add(uniqueKey); - } - } - } + if (getIncludeUniqueKeys()) + for (SchemaDefinition s : getSchemata()) + for (TableDefinition table : getTables(s)) + for (UniqueKeyDefinition uniqueKey : table.getUniqueKeys()) + uniqueKeys.add(uniqueKey); } - if (uniqueKeysBySchema == null) { + if (uniqueKeysBySchema == null) uniqueKeysBySchema = new LinkedHashMap>(); - } return filterSchema(uniqueKeys, schema, uniqueKeysBySchema); } @@ -853,18 +940,15 @@ public abstract class AbstractDatabase implements Database { if (foreignKeys == null) { foreignKeys = new ArrayList(); - for (SchemaDefinition s : getSchemata()) { - for (TableDefinition table : getTables(s)) { - for (ForeignKeyDefinition foreignKey : table.getForeignKeys()) { - foreignKeys.add(foreignKey); - } - } - } + if (getIncludeForeignKeys()) + for (SchemaDefinition s : getSchemata()) + for (TableDefinition table : getTables(s)) + for (ForeignKeyDefinition foreignKey : table.getForeignKeys()) + foreignKeys.add(foreignKey); } - if (foreignKeysBySchema == null) { + if (foreignKeysBySchema == null) foreignKeysBySchema = new LinkedHashMap>(); - } return filterSchema(foreignKeys, schema, foreignKeysBySchema); } @@ -874,18 +958,14 @@ public abstract class AbstractDatabase implements Database { if (checkConstraints == null) { checkConstraints = new ArrayList(); - for (SchemaDefinition s : getSchemata()) { - for (TableDefinition table : getTables(s)) { - for (CheckConstraintDefinition checkConstraint : table.getCheckConstraints()) { + for (SchemaDefinition s : getSchemata()) + for (TableDefinition table : getTables(s)) + for (CheckConstraintDefinition checkConstraint : table.getCheckConstraints()) checkConstraints.add(checkConstraint); - } - } - } } - if (checkConstraintsBySchema == null) { + if (checkConstraintsBySchema == null) checkConstraintsBySchema = new LinkedHashMap>(); - } return filterSchema(checkConstraints, schema, checkConstraintsBySchema); } @@ -895,19 +975,23 @@ public abstract class AbstractDatabase implements Database { if (tables == null) { tables = new ArrayList(); - try { - List t = getTables0(); + if (getIncludeTables()) { + try { + List t = getTables0(); - tables = filterExcludeInclude(t); - log.info("Tables fetched", fetchedSize(t, tables)); - } catch (Exception e) { - log.error("Error while fetching tables", e); + tables = filterExcludeInclude(t); + log.info("Tables fetched", fetchedSize(t, tables)); + } + catch (Exception e) { + log.error("Error while fetching tables", e); + } } + else + log.info("Tables excluded"); } - if (tablesBySchema == null) { + if (tablesBySchema == null) tablesBySchema = new LinkedHashMap>(); - } return filterSchema(tables, schema, tablesBySchema); } @@ -934,14 +1018,14 @@ public abstract class AbstractDatabase implements Database { enums.addAll(getConfiguredEnums()); log.info("Enums fetched", fetchedSize(e, enums)); - } catch (Exception e) { + } + catch (Exception e) { log.error("Error while fetching enums", e); } } - if (enumsBySchema == null) { + if (enumsBySchema == null) enumsBySchema = new LinkedHashMap>(); - } return filterSchema(enums, schema, enumsBySchema); } @@ -1034,7 +1118,8 @@ public abstract class AbstractDatabase implements Database { domains = filterExcludeInclude(e); log.info("Domains fetched", fetchedSize(e, domains)); - } catch (Exception e) { + } + catch (Exception e) { log.error("Error while fetching domains", e); } } @@ -1057,19 +1142,23 @@ public abstract class AbstractDatabase implements Database { if (arrays == null) { arrays = new ArrayList(); - try { - List a = getArrays0(); + if (getIncludeUDTs()) { + try { + List a = getArrays0(); - arrays = filterExcludeInclude(a); - log.info("ARRAYs fetched", fetchedSize(a, arrays)); - } catch (Exception e) { - log.error("Error while fetching ARRAYS", e); + arrays = filterExcludeInclude(a); + log.info("ARRAYs fetched", fetchedSize(a, arrays)); + } + catch (Exception e) { + log.error("Error while fetching ARRAYS", e); + } } + else + log.info("ARRAYs excluded"); } - if (arraysBySchema == null) { + if (arraysBySchema == null) arraysBySchema = new LinkedHashMap>(); - } return filterSchema(arrays, schema, arraysBySchema); } @@ -1089,19 +1178,23 @@ public abstract class AbstractDatabase implements Database { if (udts == null) { udts = new ArrayList(); - try { - List u = getUDTs0(); + if (getIncludeUDTs()) { + try { + List u = getUDTs0(); - udts = filterExcludeInclude(u); - log.info("UDTs fetched", fetchedSize(u, udts)); - } catch (Exception e) { - log.error("Error while fetching udts", e); + udts = filterExcludeInclude(u); + log.info("UDTs fetched", fetchedSize(u, udts)); + } + catch (Exception e) { + log.error("Error while fetching udts", e); + } } + else + log.info("UDTs excluded"); } - if (udtsBySchema == null) { + if (udtsBySchema == null) udtsBySchema = new LinkedHashMap>(); - } return filterSchema(udts, schema, udtsBySchema); } @@ -1141,19 +1234,23 @@ public abstract class AbstractDatabase implements Database { if (routines == null) { routines = new ArrayList(); - try { - List r = getRoutines0(); + if (getIncludeRoutines()) { + try { + List r = getRoutines0(); - routines = filterExcludeInclude(r); - log.info("Routines fetched", fetchedSize(r, routines)); - } catch (Exception e) { - log.error("Error while fetching functions", e); + routines = filterExcludeInclude(r); + log.info("Routines fetched", fetchedSize(r, routines)); + } + catch (Exception e) { + log.error("Error while fetching functions", e); + } } + else + log.info("Routines excluded"); } - if (routinesBySchema == null) { + if (routinesBySchema == null) routinesBySchema = new LinkedHashMap>(); - } return filterSchema(routines, schema, routinesBySchema); } @@ -1163,19 +1260,23 @@ public abstract class AbstractDatabase implements Database { if (packages == null) { packages = new ArrayList(); - try { - List p = getPackages0(); + if (getIncludePackages()) { + try { + List p = getPackages0(); - packages = filterExcludeInclude(p); - log.info("Packages fetched", fetchedSize(p, packages)); - } catch (Exception e) { - log.error("Error while fetching packages", e); + packages = filterExcludeInclude(p); + log.info("Packages fetched", fetchedSize(p, packages)); + } + catch (Exception e) { + log.error("Error while fetching packages", e); + } } + else + log.info("Packages excluded"); } - if (packagesBySchema == null) { + if (packagesBySchema == null) packagesBySchema = new LinkedHashMap>(); - } return filterSchema(packages, schema, packagesBySchema); } diff --git a/jOOQ-meta/src/main/java/org/jooq/util/Database.java b/jOOQ-meta/src/main/java/org/jooq/util/Database.java index 5af8a498bc..814ea10f8c 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/Database.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/Database.java @@ -267,6 +267,86 @@ public interface Database { */ boolean getIncludeExcludeColumns(); + /** + * whether foreign key relationships should be included. + */ + void setIncludeForeignKeys(boolean includeForeignKeys); + + /** + * whether foreign key relationships should be included. + */ + boolean getIncludeForeignKeys(); + + /** + * whether unique keys should be included. + */ + void setIncludeUniqueKeys(boolean includeUniqueKeys); + + /** + * whether unique keys should be included. + */ + boolean getIncludeUniqueKeys(); + + /** + * whether primary keys should be included. + */ + void setIncludePrimaryKeys(boolean includePrimaryKeys); + + /** + * whether primary keys should be included. + */ + boolean getIncludePrimaryKeys(); + + /** + * whether sequences should be included. + */ + void setIncludeSequences(boolean includeSequences); + + /** + * whether sequences should be included. + */ + boolean getIncludeSequences(); + + /** + * whether user defined types should be included. + */ + void setIncludeUDTs(boolean includeUDTs); + + /** + * whether user defined types should be included. + */ + boolean getIncludeUDTs(); + + /** + * whether packages should be included. + */ + void setIncludePackages(boolean includePackages); + + /** + * whether packages should be included. + */ + boolean getIncludePackages(); + + /** + * whether routines should be included. + */ + void setIncludeRoutines(boolean includeRoutines); + + /** + * whether routines should be included. + */ + boolean getIncludeRoutines(); + + /** + * Whether tables (and views) should be included. + */ + void setIncludeTables(boolean includeTables); + + /** + * Whether tables (and views) should be included. + */ + boolean getIncludeTables(); + /** * [#3488] Add an additional filter to the database that is applied in * addition to include / exclude. diff --git a/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.8.0.xsd b/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.8.0.xsd index 425dd700e4..ba537903e6 100644 --- a/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.8.0.xsd +++ b/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.8.0.xsd @@ -395,6 +395,15 @@ --> + + + + + + + + +