diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/DefaultGeneratorStrategy.java b/jOOQ-codegen/src/main/java/org/jooq/util/DefaultGeneratorStrategy.java index ac561c454b..9f06497d48 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/util/DefaultGeneratorStrategy.java +++ b/jOOQ-codegen/src/main/java/org/jooq/util/DefaultGeneratorStrategy.java @@ -136,43 +136,55 @@ public class DefaultGeneratorStrategy extends AbstractGeneratorStrategy { sb.append(getTargetPackage()); - // [#282] In multi-schema setups, the schema name goes into the package - if (definition.getDatabase().getSchemata().size() > 1) { + // [#2032] In multi-catalog setups, the catalog name goes into the package + if (definition.getDatabase().getCatalogs().size() > 1) { sb.append("."); - sb.append(getJavaIdentifier(definition.getSchema()).toLowerCase()); + sb.append(getJavaIdentifier(definition.getCatalog()).toLowerCase()); } - // Some definitions have their dedicated subpackages, e.g. "tables", "routines" - if (!StringUtils.isBlank(getSubPackage(definition))) { - sb.append("."); - sb.append(getSubPackage(definition)); - } + if (!(definition instanceof CatalogDefinition)) { - // Record are yet in another subpackage - if (mode == Mode.RECORD) { - sb.append(".records"); - } + // [#282] In multi-schema setups, the schema name goes into the package + if (definition.getDatabase().getSchemata().size() > 1) { + sb.append("."); + sb.append(getJavaIdentifier(definition.getSchema()).toLowerCase()); + } - // POJOs too - else if (mode == Mode.POJO) { - sb.append(".pojos"); - } + if (!(definition instanceof SchemaDefinition)) { - // DAOs too - else if (mode == Mode.DAO) { - sb.append(".daos"); - } + // Some definitions have their dedicated subpackages, e.g. "tables", "routines" + if (!StringUtils.isBlank(getSubPackage(definition))) { + sb.append("."); + sb.append(getSubPackage(definition)); + } - // Interfaces too - else if (mode == Mode.INTERFACE) { - sb.append(".interfaces"); - } + // Record are yet in another subpackage + if (mode == Mode.RECORD) { + sb.append(".records"); + } - /* [pro] xx - xxxx xx xxxxxxxxxxx xxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxx x - xxxxxxxxxxxxxxxxx - x - xx [/pro] */ + // POJOs too + else if (mode == Mode.POJO) { + sb.append(".pojos"); + } + + // DAOs too + else if (mode == Mode.DAO) { + sb.append(".daos"); + } + + // Interfaces too + else if (mode == Mode.INTERFACE) { + sb.append(".interfaces"); + } + + /* [pro] xx + xxxx xx xxxxxxxxxxx xxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxx x + xxxxxxxxxxxxxxxxx + x + xx [/pro] */ + } + } return sb.toString(); } 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 7e1d462636..fa036c468a 100644 --- a/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java +++ b/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java @@ -94,6 +94,7 @@ import org.jooq.exception.SQLDialectNotSupportedException; import org.jooq.impl.AbstractKeys; import org.jooq.impl.AbstractRoutine; // ... +import org.jooq.impl.CatalogImpl; import org.jooq.impl.DAOImpl; import org.jooq.impl.DSL; import org.jooq.impl.DefaultDataType; @@ -133,45 +134,45 @@ import org.jooq.util.postgres.PostgresDatabase; */ public class JavaGenerator extends AbstractGenerator { - private static final JooqLogger log = JooqLogger.getLogger(JavaGenerator.class); + private static final JooqLogger log = JooqLogger.getLogger(JavaGenerator.class); /** * The Javadoc to be used for private constructors */ - private static final String NO_FURTHER_INSTANCES_ALLOWED = "No further instances allowed"; + private static final String NO_FURTHER_INSTANCES_ALLOWED = "No further instances allowed"; /** * [#1459] Prevent large static initialisers by splitting nested classes */ - private static final int INITIALISER_SIZE = 500; + private static final int INITIALISER_SIZE = 500; /** * An overall stop watch to measure the speed of source code generation */ - private final StopWatch watch = new StopWatch(); + private final StopWatch watch = new StopWatch(); /** * The underlying database of this generator */ - private Database database; + private Database database; /** * The code generation date, if needed. */ - private String isoDate; + private String isoDate; /** - * The cached schema version numbers + * The cached catalog version numbers */ - private Map schemaVersions; + private Map catalogVersions; /** * All files modified by this generator */ - private Set files = new LinkedHashSet(); + private Set files = new LinkedHashSet(); - private final boolean scala; - private final String tokenVoid; + private final boolean scala; + private final String tokenVoid; public JavaGenerator() { this(JAVA); @@ -187,7 +188,7 @@ public class JavaGenerator extends AbstractGenerator { @Override public final void generate(Database db) { this.isoDate = DatatypeConverter.printDateTime(Calendar.getInstance(TimeZone.getTimeZone("UTC"))); - this.schemaVersions = new LinkedHashMap(); + this.catalogVersions = new LinkedHashMap(); this.database = db; this.database.addFilter(new AvoidAmbiguousClassesFilter()); @@ -259,10 +260,24 @@ public class JavaGenerator extends AbstractGenerator { log.info("----------------------------------------------------------"); // ---------------------------------------------------------------------- - // XXX Generating schemas + // XXX Generating catalogs // ---------------------------------------------------------------------- - log.info("Generating schemata", "Total: " + database.getSchemata().size()); - for (SchemaDefinition schema : database.getSchemata()) { + log.info("Generating catalogs", "Total: " + database.getCatalogs().size()); + for (CatalogDefinition catalog : database.getCatalogs()) { + try { + generate(catalog); + } + catch (Exception e) { + throw new GeneratorException("Error generating code for catalog " + catalog, e); + } + } + } + + private final void generate(CatalogDefinition catalog) { + generateCatalog(catalog); + + log.info("Generating schemata", "Total: " + catalog.getSchemata().size()); + for (SchemaDefinition schema : catalog.getSchemata()) { try { generate(schema); } @@ -279,7 +294,7 @@ public class JavaGenerator extends AbstractGenerator { log.info("No schema version is applied for schema " + schema.getInputName() + ". Regenerating."); } else { - schemaVersions.put(schema, newVersion); + catalogVersions.put(schema.getCatalog(), newVersion); String oldVersion = readVersion(getStrategy().getFile(schema)); if (StringUtils.isBlank(oldVersion)) { @@ -388,7 +403,8 @@ public class JavaGenerator extends AbstractGenerator { files.clear(); // XXX [#651] Refactoring-cursor - watch.splitInfo("GENERATION FINISHED: " + schema.getQualifiedName()); + watch.splitInfo("Generation finished: " + schema.getQualifiedName()); + log.info(""); } private class AvoidAmbiguousClassesFilter implements Database.Filter { @@ -437,7 +453,7 @@ public class JavaGenerator extends AbstractGenerator { xxxxxxxxxx xxx x xxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxx xxxxxxxx xxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxx xxxxxx xx xxx xxxxxx xx x x xxxxxxxxxxxxxxxxxxxxxxxx - xxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxx + xxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxx xx xxxxxxx xxxxxxxxxxxxxxxxxxx xxxxxx xxxx @@ -474,7 +490,7 @@ public class JavaGenerator extends AbstractGenerator { xxxxxxxxxx xxx x xxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxx xxxxxxxx xxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxx xxxxxx xx xxx xxxxxxxx xxxxx xx x x xxxxxxxxxxxxxxxxxxxxxxxx - xxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxx + xxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxx xx xxxxxxx xxxxxxxxxxxxxxxxxxx xxxxx xxxx @@ -518,7 +534,7 @@ public class JavaGenerator extends AbstractGenerator { printPackage(out, schema); printClassJavadoc(out, "A class modelling foreign key relationships between tables of the " + schema.getOutputName() + " schema"); - printClassAnnotations(out, schema); + printClassAnnotations(out, schema.getCatalog()); if (scala) out.println("object Keys {"); @@ -821,7 +837,7 @@ public class JavaGenerator extends AbstractGenerator { else generateUDTRecordClassJavadoc((UDTDefinition) tableOrUdt, out); - printClassAnnotations(out, tableOrUdt.getSchema()); + printClassAnnotations(out, tableOrUdt.getSchema().getCatalog()); if (tableOrUdt instanceof TableDefinition) printTableJPAAnnotation(out, (TableDefinition) tableOrUdt); @@ -1296,7 +1312,7 @@ public class JavaGenerator extends AbstractGenerator { else generateUDTInterfaceClassJavadoc((UDTDefinition) tableOrUDT, out); - printClassAnnotations(out, tableOrUDT.getSchema()); + printClassAnnotations(out, tableOrUDT.getSchema().getCatalog()); if (tableOrUDT instanceof TableDefinition) printTableJPAAnnotation(out, (TableDefinition) tableOrUDT); @@ -1403,6 +1419,7 @@ public class JavaGenerator extends AbstractGenerator { } protected void generateUDT(UDTDefinition udt, JavaWriter out) { + final CatalogDefinition catalog = udt.getCatalog(); final SchemaDefinition schema = udt.getSchema(); final String className = getStrategy().getJavaClassName(udt); final String recordType = out.ref(getStrategy().getFullJavaClassName(udt, Mode.RECORD)); @@ -1429,7 +1446,7 @@ public class JavaGenerator extends AbstractGenerator { } generateUDTClassJavadoc(udt, out); - printClassAnnotations(out, schema); + printClassAnnotations(out, catalog); // [#799] Oracle UDTs with member procedures have similarities with packages if (udt.getRoutines().size() > 0) { @@ -1646,7 +1663,7 @@ public class JavaGenerator extends AbstractGenerator { printPackage(out, schema); printClassJavadoc(out, "Convenience access to all UDTs in " + schema.getOutputName()); - printClassAnnotations(out, schema); + printClassAnnotations(out, schema.getCatalog()); if (scala) out.println("object UDTs {"); @@ -1698,6 +1715,7 @@ public class JavaGenerator extends AbstractGenerator { protected void generateArray(ArrayDefinition array, JavaWriter out) { /* [pro] xx xxxxx xxxxxxxxxxxxxxxx xxxxxx x xxxxxxxxxxxxxxxxxx + xxxxx xxxxxxxxxxxxxxxxx xxxxxxx x xxxxxxxxxxxxxxxxxxx xxxxx xxxxxx xxxxxxxxx x xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxx xxxxx xxxxxx xxxxxxxxxxx x xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxx xxxxxx xxxxxxxxxxxxxx x xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxx @@ -1711,7 +1729,7 @@ public class JavaGenerator extends AbstractGenerator { xxxxxxxxxxxxxxxxx xxxxxx xxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxx - xxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxx + xxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxx xx xxxxxxx xxxxxxxxxxxxxxxxxx xx xxxxxxx xxxxxxxxxx xxxxxxx xxxxxxxxxxxx xxxxx xxxxxxxxxxxxxxxx xxxx xxxxxxxxxxxx xxxx xxxxxx xxx @@ -1845,7 +1863,7 @@ public class JavaGenerator extends AbstractGenerator { printPackage(out, e); generateEnumClassJavadoc(e, out); - printClassAnnotations(out, e.getSchema()); + printClassAnnotations(out, e.getSchema().getCatalog()); interfaces.add(out.ref(EnumType.class)); @@ -1924,7 +1942,7 @@ public class JavaGenerator extends AbstractGenerator { printPackage(out, d); generateDomainClassJavadoc(d, out); - printClassAnnotations(out, d.getSchema()); + printClassAnnotations(out, d.getSchema().getCatalog()); for (String clause : d.getCheckClauses()) out.println("// " + clause); @@ -1954,7 +1972,7 @@ public class JavaGenerator extends AbstractGenerator { JavaWriter out = newJavaWriter(new File(getStrategy().getFile(schema).getParentFile(), "Routines.java")); printPackage(out, schema); printClassJavadoc(out, "Convenience access to all stored procedures and functions in " + schema.getOutputName()); - printClassAnnotations(out, schema); + printClassAnnotations(out, schema.getCatalog()); if (scala) out.println("object Routines {"); @@ -2063,6 +2081,7 @@ public class JavaGenerator extends AbstractGenerator { xxxxxxxxx xxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxx xxxxxxxxxx xxxx x xx xxxxx xx xxxxx xxxxxxxxxxxxxxxx xxxxxx x xxxxxxxxxxxxxxxx + xxxxx xxxxxxxxxxxxxxxxx xxxxxxx x xxxxxxxxxxxxxxxxx xxxxx xxxxxx xxxxxxxxx x xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxx xxxxxx xxxxxxxxxx x xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxx xxxxxx xxxxxxxxxxxxxxxx x xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxx @@ -2071,7 +2090,7 @@ public class JavaGenerator extends AbstractGenerator { xx xxxxxx xxxxxxxxxxx xxxxxxx xxxxxxxxxxxxxxxxx xxxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxx - xxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxx + xxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxxxxx xx xxxxxxx x xxxxxxxxxxxxxxxxxxx xx xxxxxxx xxxxxxxxxx xxxxxxxxxxxx xxxx xxxxxxxxxxxx xxxx xxxxxx xxx xxxxxxxxxx xxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxxxxxxxx xxxxxxxxxxxx @@ -2136,7 +2155,7 @@ public class JavaGenerator extends AbstractGenerator { printPackage(out, schema); printClassJavadoc(out, "Convenience access to all tables in " + schema.getOutputName()); - printClassAnnotations(out, schema); + printClassAnnotations(out, schema.getCatalog()); if (scala) out.println("object Tables {"); @@ -2236,7 +2255,7 @@ public class JavaGenerator extends AbstractGenerator { printPackage(out, table, Mode.DAO); generateDaoClassJavadoc(table, out); - printClassAnnotations(out, table.getSchema()); + printClassAnnotations(out, table.getSchema().getCatalog()); if (generateSpringAnnotations()) out.println("@%s", out.ref("org.springframework.stereotype.Repository")); @@ -2435,7 +2454,7 @@ public class JavaGenerator extends AbstractGenerator { else generateUDTPojoClassJavadoc((UDTDefinition) tableOrUDT, out); - printClassAnnotations(out, tableOrUDT.getSchema()); + printClassAnnotations(out, tableOrUDT.getSchema().getCatalog()); if (tableOrUDT instanceof TableDefinition) printTableJPAAnnotation(out, (TableDefinition) tableOrUDT); @@ -2928,6 +2947,7 @@ public class JavaGenerator extends AbstractGenerator { protected void generateTable(TableDefinition table, JavaWriter out) { final SchemaDefinition schema = table.getSchema(); + final CatalogDefinition catalog = table.getCatalog(); final UniqueKeyDefinition primaryKey = table.getPrimaryKey(); final boolean updatable = generateRelations() && primaryKey != null; @@ -2956,7 +2976,7 @@ public class JavaGenerator extends AbstractGenerator { } generateTableClassJavadoc(table, out); - printClassAnnotations(out, schema); + printClassAnnotations(out, catalog); if (scala) { out.println("class %s(alias : String, aliased : %s[%s], parameters : Array[ %s[_] ]) extends %s[%s](alias, %s, aliased, parameters, \"%s\")[[before= with ][separator= with ][%s]] {", @@ -3323,7 +3343,7 @@ public class JavaGenerator extends AbstractGenerator { printPackage(out, schema); printClassJavadoc(out, "Convenience access to all sequences in " + schema.getOutputName()); - printClassAnnotations(out, schema); + printClassAnnotations(out, schema.getCatalog()); if (scala) out.println("object Sequences {"); @@ -3351,6 +3371,68 @@ public class JavaGenerator extends AbstractGenerator { watch.splitInfo("Sequences generated"); } + protected void generateCatalog(CatalogDefinition catalog) { + JavaWriter out = newJavaWriter(getStrategy().getFile(catalog)); + log.info(""); + log.info("Generating catalog", out.file().getName()); + log.info("=========================================================="); + generateCatalog(catalog, out); + closeJavaWriter(out); + } + + protected void generateCatalog(CatalogDefinition catalog, JavaWriter out) { + final String catalogName = catalog.getQualifiedOutputName(); + final String catalogId = getStrategy().getJavaIdentifier(catalog); + final String className = getStrategy().getJavaClassName(catalog); + final List interfaces = out.ref(getStrategy().getJavaClassImplements(catalog, Mode.DEFAULT)); + + printPackage(out, catalog); + + if (scala) { + out.println("object %s {", className); + out.tab(1).javadoc("The reference instance of %s", catalogName); + out.tab(1).println("val %s = new %s", catalogId, className); + out.println("}"); + out.println(); + } + + generateCatalogClassJavadoc(catalog, out); + printClassAnnotations(out, catalog); + + if (scala) { + out.println("class %s extends %s(\"%s\")[[before= with ][separator= with ][%s]] {", className, CatalogImpl.class, catalog.getOutputName(), interfaces); + } + else { + out.println("public class %s extends %s[[before= implements ][%s]] {", className, CatalogImpl.class, interfaces); + out.printSerial(); + out.tab(1).javadoc("The reference instance of %s", catalogName); + out.tab(1).println("public static final %s %s = new %s();", className, catalogId, className); + + out.tab(1).javadoc(NO_FURTHER_INSTANCES_ALLOWED); + out.tab(1).println("private %s() {", className); + out.tab(2).println("super(\"%s\");", catalog.getOutputName()); + out.tab(1).println("}"); + } + + printReferences(out, database.getSchemata(catalog), Schema.class, false); + + generateCatalogClassFooter(catalog, out); + out.println("}"); + } + + /** + * Subclasses may override this method to provide catalog class footer code. + */ + @SuppressWarnings("unused") + protected void generateCatalogClassFooter(CatalogDefinition schema, JavaWriter out) {} + + /** + * Subclasses may override this method to provide their own Javadoc. + */ + protected void generateCatalogClassJavadoc(CatalogDefinition schema, JavaWriter out) { + printClassJavadoc(out, schema); + } + protected void generateSchema(SchemaDefinition schema) { JavaWriter out = newJavaWriter(getStrategy().getFile(schema)); log.info("Generating schema", out.file().getName()); @@ -3360,6 +3442,7 @@ public class JavaGenerator extends AbstractGenerator { } protected void generateSchema(SchemaDefinition schema, JavaWriter out) { + final String catalogId = out.ref(getStrategy().getFullJavaIdentifier(schema.getCatalog()), 2); final String schemaName = schema.getQualifiedOutputName(); final String schemaId = getStrategy().getJavaIdentifier(schema); final String className = getStrategy().getJavaClassName(schema); @@ -3376,10 +3459,10 @@ public class JavaGenerator extends AbstractGenerator { } generateSchemaClassJavadoc(schema, out); - printClassAnnotations(out, schema); + printClassAnnotations(out, schema.getCatalog()); if (scala) { - out.println("class %s extends %s(\"%s\")[[before= with ][separator= with ][%s]] {", className, SchemaImpl.class, schema.getOutputName(), interfaces); + out.println("class %s extends %s(\"%s\", %s)[[before= with ][separator= with ][%s]] {", className, SchemaImpl.class, schema.getOutputName(), catalogId, interfaces); } else { out.println("public class %s extends %s[[before= implements ][%s]] {", className, SchemaImpl.class, interfaces); @@ -3389,17 +3472,17 @@ public class JavaGenerator extends AbstractGenerator { out.tab(1).javadoc(NO_FURTHER_INSTANCES_ALLOWED); out.tab(1).println("private %s() {", className); - out.tab(2).println("super(\"%s\");", schema.getOutputName()); + out.tab(2).println("super(\"%s\", %s);", schema.getOutputName(), catalogId); out.tab(1).println("}"); } // [#2255] Avoid referencing sequence literals, if they're not generated if (generateGlobalObjectReferences() && generateGlobalSequenceReferences()) { - printSchemaReferences(out, database.getSequences(schema), Sequence.class, true); + printReferences(out, database.getSequences(schema), Sequence.class, true); } - printSchemaReferences(out, database.getTables(schema), Table.class, true); - printSchemaReferences(out, database.getUDTs(schema), UDT.class, true); + printReferences(out, database.getTables(schema), Table.class, true); + printReferences(out, database.getUDTs(schema), UDT.class, true); generateSchemaClassFooter(schema, out); out.println("}"); @@ -3456,7 +3539,7 @@ public class JavaGenerator extends AbstractGenerator { } } - protected void printSchemaReferences(JavaWriter out, List definitions, Class type, boolean isGeneric) { + protected void printReferences(JavaWriter out, List definitions, Class type, boolean isGeneric) { if (out != null && !definitions.isEmpty()) { final String generic = isGeneric ? (scala ? "[_]" : "") : ""; final List references = out.ref(getStrategy().getFullJavaIdentifiers(definitions), 2); @@ -3640,6 +3723,7 @@ public class JavaGenerator extends AbstractGenerator { } protected void generateRoutine(RoutineDefinition routine, JavaWriter out) { + final CatalogDefinition catalog = routine.getCatalog(); final SchemaDefinition schema = routine.getSchema(); final String className = getStrategy().getJavaClassName(routine); final String returnType = (routine.getReturnValue() == null) @@ -3687,7 +3771,7 @@ public class JavaGenerator extends AbstractGenerator { } generateRoutineClassJavadoc(routine, out); - printClassAnnotations(out, schema); + printClassAnnotations(out, catalog); if (scala) { out.println("class %s extends %s[%s](\"%s\", %s[[before=, ][%s]][[before=, ][%s]][[before=, ][new %s()]])[[before= with ][separator= with ][%s]] {", @@ -4301,7 +4385,7 @@ public class JavaGenerator extends AbstractGenerator { out.println(" */"); } - protected void printClassAnnotations(JavaWriter out, SchemaDefinition schema) { + protected void printClassAnnotations(JavaWriter out, CatalogDefinition catalog) { if (generateGeneratedAnnotation()) { out.println("@%s(", out.ref("javax.annotation.Generated")); @@ -4313,7 +4397,7 @@ public class JavaGenerator extends AbstractGenerator { out.tab(2).println("\"http://www.jooq.org\","); out.tab(2).println("\"jOOQ version:%s\",", Constants.VERSION); - out.tab(2).println("\"schema version:%s\"", schemaVersions.get(schema).replace("\"", "\\\"")); + out.tab(2).println("\"catalog version:%s\"", catalogVersions.get(catalog).replace("\"", "\\\"")); if (scala) out.tab(1).println("),"); diff --git a/jOOQ-meta-extensions/src/main/java/org/jooq/util/vertabelo/VertabeloXMLDatabase.java b/jOOQ-meta-extensions/src/main/java/org/jooq/util/vertabelo/VertabeloXMLDatabase.java index 5ae0323708..da01f5cff0 100644 --- a/jOOQ-meta-extensions/src/main/java/org/jooq/util/vertabelo/VertabeloXMLDatabase.java +++ b/jOOQ-meta-extensions/src/main/java/org/jooq/util/vertabelo/VertabeloXMLDatabase.java @@ -55,6 +55,7 @@ import org.jooq.tools.JooqLogger; import org.jooq.tools.StringUtils; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.CheckConstraintDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DataTypeDefinition; @@ -313,6 +314,12 @@ public class VertabeloXMLDatabase extends AbstractDatabase { }); } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } @Override protected List getSchemata0() throws SQLException { 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 fda81321b0..b0f6eb1292 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java @@ -100,8 +100,6 @@ public abstract class AbstractDatabase implements Database { private Properties properties; private SQLDialect dialect; private Connection connection; - private DSLContext create; - private DSLContext createMuted; private List regexFlags; private List filters; private String[] excludes; @@ -125,6 +123,7 @@ public abstract class AbstractDatabase implements Database { // ------------------------------------------------------------------------- private List inputSchemata; + private List catalogs; private List schemata; private List sequences; private List identities; @@ -291,6 +290,41 @@ public abstract class AbstractDatabase implements Database { return pattern; } + @Override + public final List getCatalogs() { + if (catalogs == null) { + catalogs = new ArrayList(); + + try { + catalogs = getCatalogs0(); + } + catch (Exception e) { + log.error("Could not load catalogs", e); + } + +// [#4794] Add support for schema mapping +// Iterator it = catalogs.iterator(); +// while (it.hasNext()) { +// if (!getInputSchemata().contains(it.next().getName())) { +// it.remove(); +// } +// } + } + + return catalogs; + } + + @Override + public final CatalogDefinition getCatalog(String inputName) { + for (CatalogDefinition catalog : getCatalogs()) { + if (catalog.getName().equals(inputName)) { + return catalog; + } + } + + return null; + } + @Override public final List getSchemata() { if (schemata == null) { @@ -320,6 +354,17 @@ public abstract class AbstractDatabase implements Database { return schemata; } + @Override + public final List getSchemata(CatalogDefinition catalog) { + List result = new ArrayList(); + + for (SchemaDefinition schema : getSchemata()) + if (catalog.equals(schema.getCatalog())) + result.add(schema); + + return result; + } + @Override public final SchemaDefinition getSchema(String inputName) { for (SchemaDefinition schema : getSchemata()) { @@ -1269,6 +1314,12 @@ public abstract class AbstractDatabase implements Database { */ protected abstract void loadCheckConstraints(DefaultRelations r) throws SQLException; + /** + * Retrieve ALL catalogs from the database. This will be filtered in + * {@link #getCatalogs()} + */ + protected abstract List getCatalogs0() throws SQLException; + /** * Retrieve ALL schemata from the database. This will be filtered in * {@link #getSchemata()} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/AbstractDefinition.java b/jOOQ-meta/src/main/java/org/jooq/util/AbstractDefinition.java index 3fac474508..25febff820 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/AbstractDefinition.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/AbstractDefinition.java @@ -89,6 +89,11 @@ public abstract class AbstractDefinition implements Definition { return overload; } + @Override + public /* non-final */ CatalogDefinition getCatalog() { + return getSchema().getCatalog(); + } + @Override public final SchemaDefinition getSchema() { return schema; diff --git a/jOOQ-meta/src/main/java/org/jooq/util/CatalogDefinition.java b/jOOQ-meta/src/main/java/org/jooq/util/CatalogDefinition.java new file mode 100644 index 0000000000..90ccf4b368 --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/CatalogDefinition.java @@ -0,0 +1,91 @@ +/** + * Copyright (c) 2009-2015, Data Geekery GmbH (http://www.datageekery.com) + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Other licenses: + * ----------------------------------------------------------------------------- + * Commercial licenses for this work are available. These replace the above + * ASL 2.0 and offer limited warranties, support, maintenance, and commercial + * database integrations. + * + * For more information, please visit: http://www.jooq.org/licenses + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + */ + +package org.jooq.util; + +import java.util.Arrays; +import java.util.List; + +import org.jooq.tools.StringUtils; + +/** + * The definition of a database catalog. + * + * @author Lukas Eder + */ +public class CatalogDefinition extends AbstractDefinition { + + public CatalogDefinition(Database database, String name, String comment) { + super(database, null, name, comment); + } + + @Override + public final CatalogDefinition getCatalog() { + return this; + } + + public final List getSchemata() { + return getDatabase().getSchemata(this); + } + + public final SchemaDefinition getSchema(String name) { + for (SchemaDefinition schema : getSchemata()) + if (schema.getInputName().equals(name)) + return schema; + + return null; + } + + @SuppressWarnings("deprecation") + @Override + public final String getOutputName() { + return getDatabase().getOutputSchema(getInputName()); + } + + @Override + public final List getDefinitionPath() { + return Arrays.asList(this); + } + + public boolean isDefaultCatalog() { + return StringUtils.isBlank(getOutputName()); + } +} 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 efbc7436ba..5e76c2becc 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/Database.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/Database.java @@ -61,11 +61,26 @@ import org.jooq.util.jaxb.Schema; */ public interface Database { + /** + * The catalogs generated from this database. + */ + List getCatalogs(); + + /** + * Get a catalog defined in this database by name. + */ + CatalogDefinition getCatalog(String name); + /** * The schemata generated from this database. */ List getSchemata(); + /** + * The schemata generated from this database and a given catalog. + */ + List getSchemata(CatalogDefinition catalog); + /** * Get a schema defined in this database by name. */ diff --git a/jOOQ-meta/src/main/java/org/jooq/util/Definition.java b/jOOQ-meta/src/main/java/org/jooq/util/Definition.java index 948b78d637..853e984e14 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/Definition.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/Definition.java @@ -57,7 +57,13 @@ public interface Definition { Database getDatabase(); /** - * @return The schema of this object + * @return The catalog of this object. + */ + CatalogDefinition getCatalog(); + + /** + * @return The schema of this object or null if this object is + * a {@link CatalogDefinition}. */ SchemaDefinition getSchema(); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/SchemaDefinition.java b/jOOQ-meta/src/main/java/org/jooq/util/SchemaDefinition.java index f2e8d859c2..ec42b40cc6 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/SchemaDefinition.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/SchemaDefinition.java @@ -53,11 +53,24 @@ import org.jooq.tools.StringUtils; */ public class SchemaDefinition extends AbstractDefinition { - public SchemaDefinition(Database database, String name, String comment) { - super(database, null, name, comment); - } + private final CatalogDefinition catalog; - public final List getTables() { + public SchemaDefinition(Database database, String name, String comment) { + this(database, name, comment, null); + } + + public SchemaDefinition(Database database, String name, String comment, CatalogDefinition catalog) { + super(database, null, name, comment); + + this.catalog = catalog == null ? new CatalogDefinition(database, "", "") : catalog; + } + + @Override + public final CatalogDefinition getCatalog() { + return catalog; + } + + public final List getTables() { return getDatabase().getTables(this); } @@ -69,7 +82,10 @@ public class SchemaDefinition extends AbstractDefinition { @Override public final List getDefinitionPath() { - return Arrays.asList(this); + if (StringUtils.isEmpty(catalog.getName())) + return Arrays.asList(this); + else + return Arrays.asList(catalog, this); } public boolean isDefaultSchema() { diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDDatabase.java index 354f22664a..7571c3d59e 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDDatabase.java @@ -67,6 +67,7 @@ import org.jooq.SQLDialect; import org.jooq.impl.DSL; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DataTypeDefinition; import org.jooq.util.DefaultEnumDefinition; @@ -178,6 +179,13 @@ public class CUBRIDDatabase extends AbstractDatabase { // Currently not supported } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } + @Override protected List getSchemata0() throws SQLException { List result = new ArrayList(); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/derby/DerbyDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/derby/DerbyDatabase.java index 7f5e53873c..8ff970994b 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/derby/DerbyDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/derby/DerbyDatabase.java @@ -64,6 +64,7 @@ import org.jooq.SQLDialect; import org.jooq.impl.DSL; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DataTypeDefinition; import org.jooq.util.DefaultDataTypeDefinition; @@ -225,6 +226,13 @@ public class DerbyDatabase extends AbstractDatabase { // Currently not supported } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } + @Override protected List getSchemata0() throws SQLException { List result = new ArrayList(); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/firebird/FirebirdDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/firebird/FirebirdDatabase.java index d82695e509..153ff3d8c3 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/firebird/FirebirdDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/firebird/FirebirdDatabase.java @@ -65,6 +65,7 @@ import org.jooq.SQLDialect; import org.jooq.impl.DSL; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DataTypeDefinition; import org.jooq.util.DefaultDataTypeDefinition; @@ -196,6 +197,13 @@ public class FirebirdDatabase extends AbstractDatabase { // Currently not supported } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } + @Override protected List getSchemata0() throws SQLException { List result = new ArrayList(); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/h2/H2Database.java b/jOOQ-meta/src/main/java/org/jooq/util/h2/H2Database.java index 3572cfb69c..cfcf3bf9b6 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/h2/H2Database.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/h2/H2Database.java @@ -63,6 +63,7 @@ import org.jooq.SQLDialect; import org.jooq.impl.DSL; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DefaultCheckConstraintDefinition; import org.jooq.util.DefaultDataTypeDefinition; @@ -227,6 +228,13 @@ public class H2Database extends AbstractDatabase { } } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } + @Override protected List getSchemata0() throws SQLException { List result = new ArrayList(); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/hsqldb/HSQLDBDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/hsqldb/HSQLDBDatabase.java index f8c25c1e9e..be4149975b 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/hsqldb/HSQLDBDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/hsqldb/HSQLDBDatabase.java @@ -68,6 +68,7 @@ import org.jooq.impl.DSL; import org.jooq.tools.JooqLogger; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DataTypeDefinition; import org.jooq.util.DefaultCheckConstraintDefinition; @@ -223,6 +224,12 @@ public class HSQLDBDatabase extends AbstractDatabase { } } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } @Override protected List getSchemata0() throws SQLException { diff --git a/jOOQ-meta/src/main/java/org/jooq/util/jdbc/JDBCDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/jdbc/JDBCDatabase.java index 6efa2b7583..3b09d09099 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/jdbc/JDBCDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/jdbc/JDBCDatabase.java @@ -54,6 +54,7 @@ import org.jooq.UniqueKey; import org.jooq.impl.DSL; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DataTypeDefinition; import org.jooq.util.DefaultDataTypeDefinition; @@ -118,6 +119,13 @@ public class JDBCDatabase extends AbstractDatabase { protected void loadCheckConstraints(DefaultRelations r) throws SQLException { } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } + @Override protected List getSchemata0() throws SQLException { List result = new ArrayList(); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/mysql/MySQLDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/mysql/MySQLDatabase.java index f443877232..af3e79742a 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/mysql/MySQLDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/mysql/MySQLDatabase.java @@ -72,6 +72,7 @@ import org.jooq.tools.JooqLogger; import org.jooq.tools.csv.CSVReader; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DefaultEnumDefinition; import org.jooq.util.DefaultRelations; @@ -205,6 +206,13 @@ public class MySQLDatabase extends AbstractDatabase { // Currently not supported } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } + @Override protected List getSchemata0() throws SQLException { List result = new ArrayList(); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/postgres/PostgresDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/postgres/PostgresDatabase.java index 88d914eced..556c23f6b0 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/postgres/PostgresDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/postgres/PostgresDatabase.java @@ -91,6 +91,7 @@ import org.jooq.impl.DSL; import org.jooq.tools.JooqLogger; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DataTypeDefinition; import org.jooq.util.DefaultCheckConstraintDefinition; @@ -358,6 +359,13 @@ public class PostgresDatabase extends AbstractDatabase { return result; } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } + @Override protected List getSchemata0() throws SQLException { List result = new ArrayList(); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/sqlite/SQLiteDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/sqlite/SQLiteDatabase.java index 2476cc3667..65beb34790 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/sqlite/SQLiteDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/sqlite/SQLiteDatabase.java @@ -54,6 +54,7 @@ import org.jooq.SQLDialect; import org.jooq.impl.DSL; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DefaultRelations; import org.jooq.util.DomainDefinition; @@ -177,6 +178,13 @@ public class SQLiteDatabase extends AbstractDatabase { // Currently not supported } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } + @Override protected List getSchemata0() throws SQLException { List result = new ArrayList(); diff --git a/jOOQ-meta/src/main/java/org/jooq/util/xml/XMLDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/xml/XMLDatabase.java index 9946d81a80..d65901e4d9 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/xml/XMLDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/xml/XMLDatabase.java @@ -71,6 +71,7 @@ import org.jooq.tools.JooqLogger; import org.jooq.tools.StringUtils; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; +import org.jooq.util.CatalogDefinition; import org.jooq.util.ColumnDefinition; import org.jooq.util.DataTypeDefinition; import org.jooq.util.DefaultDataTypeDefinition; @@ -297,6 +298,13 @@ public class XMLDatabase extends AbstractDatabase { protected void loadCheckConstraints(DefaultRelations r) { } + @Override + protected List getCatalogs0() throws SQLException { + List result = new ArrayList(); + result.add(new CatalogDefinition(this, "", "")); + return result; + } + @Override protected List getSchemata0() { List result = new ArrayList(); @@ -308,7 +316,6 @@ public class XMLDatabase extends AbstractDatabase { return result; } - @Override protected List getSequences0() { List result = new ArrayList();