From 0afabfd73cf17430b8973ae3513c7251c50d694b Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Thu, 3 Oct 2019 11:19:47 +0200 Subject: [PATCH] [jOOQ/jOOQ#8528] DDL interpretation improvements --- .../java/org/jooq/impl/AbstractRoutine.java | 6 + .../java/org/jooq/impl/AlterSchemaImpl.java | 4 + .../java/org/jooq/impl/BatchMultiple.java | 6 + .../main/java/org/jooq/impl/BatchSingle.java | 6 + .../java/org/jooq/impl/DDLInterpreter.java | 473 +++++++++++------- .../jooq/impl/DDLInterpreterMetaProvider.java | 9 +- jOOQ/src/main/java/org/jooq/impl/Fields.java | 11 - 7 files changed, 332 insertions(+), 183 deletions(-) diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java b/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java index d7670b0a24..977794cda6 100644 --- a/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java +++ b/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java @@ -133,6 +133,7 @@ import org.jooq.UDT; import org.jooq.UDTField; import org.jooq.UDTRecord; import org.jooq.XMLFormat; +import org.jooq.conf.SettingsTools; import org.jooq.exception.ControlFlowSignal; import org.jooq.exception.MappingException; import org.jooq.impl.ResultsImpl.ResultOrRowsImpl; @@ -492,6 +493,11 @@ public abstract class AbstractRoutine extends AbstractNamed implements Routin // [#1856] TODO: Add Statement flags like timeout here listener.prepareEnd(ctx); + // [#9295] use query timeout from settings + int t = SettingsTools.getQueryTimeout(0, ctx.settings()); + if (t != 0) + ctx.statement().setQueryTimeout(t); + listener.bindStart(ctx); using(configuration).bindContext(ctx.statement()).visit(this); registerOutParameters(ctx); diff --git a/jOOQ/src/main/java/org/jooq/impl/AlterSchemaImpl.java b/jOOQ/src/main/java/org/jooq/impl/AlterSchemaImpl.java index 43dec17e1a..9d2dff80f6 100644 --- a/jOOQ/src/main/java/org/jooq/impl/AlterSchemaImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/AlterSchemaImpl.java @@ -83,6 +83,10 @@ final class AlterSchemaImpl extends AbstractRowCountQuery implements this.ifExists = ifExists; } + final Schema $schema() { return schema; } + final boolean $ifExists() { return ifExists; } + final Schema $renameTo() { return renameTo; } + // ------------------------------------------------------------------------ // XXX: DSL API // ------------------------------------------------------------------------ diff --git a/jOOQ/src/main/java/org/jooq/impl/BatchMultiple.java b/jOOQ/src/main/java/org/jooq/impl/BatchMultiple.java index c2373e851f..65585ce8d7 100644 --- a/jOOQ/src/main/java/org/jooq/impl/BatchMultiple.java +++ b/jOOQ/src/main/java/org/jooq/impl/BatchMultiple.java @@ -45,6 +45,7 @@ import org.jooq.Configuration; import org.jooq.ExecuteContext; import org.jooq.ExecuteListener; import org.jooq.Query; +import org.jooq.conf.SettingsTools; import org.jooq.exception.ControlFlowSignal; /** @@ -99,6 +100,11 @@ final class BatchMultiple implements Batch { listener.prepareEnd(ctx); } + // [#9295] use query timeout from settings + int t = SettingsTools.getQueryTimeout(0, ctx.settings()); + if (t != 0) + ctx.statement().setQueryTimeout(t); + listener.executeStart(ctx); int[] result = ctx.statement().executeBatch(); diff --git a/jOOQ/src/main/java/org/jooq/impl/BatchSingle.java b/jOOQ/src/main/java/org/jooq/impl/BatchSingle.java index d3f901a323..1a0baebdc2 100644 --- a/jOOQ/src/main/java/org/jooq/impl/BatchSingle.java +++ b/jOOQ/src/main/java/org/jooq/impl/BatchSingle.java @@ -60,6 +60,7 @@ import org.jooq.ExecuteContext; import org.jooq.ExecuteListener; import org.jooq.Param; import org.jooq.Query; +import org.jooq.conf.SettingsTools; import org.jooq.exception.ControlFlowSignal; import org.jooq.tools.JooqLogger; @@ -213,6 +214,11 @@ final class BatchSingle implements BatchBindStep { ctx.statement(connection.prepareStatement(ctx.sql())); listener.prepareEnd(ctx); + // [#9295] use query timeout from settings + int t = SettingsTools.getQueryTimeout(0, ctx.settings()); + if (t != 0) + ctx.statement().setQueryTimeout(t); + for (Object[] bindValues : allBindValues) { listener.bindStart(ctx); diff --git a/jOOQ/src/main/java/org/jooq/impl/DDLInterpreter.java b/jOOQ/src/main/java/org/jooq/impl/DDLInterpreter.java index 4831e3a4a9..6f1cac6fff 100644 --- a/jOOQ/src/main/java/org/jooq/impl/DDLInterpreter.java +++ b/jOOQ/src/main/java/org/jooq/impl/DDLInterpreter.java @@ -37,20 +37,17 @@ */ package org.jooq.impl; +import static org.jooq.impl.AbstractName.NO_NAME; import static org.jooq.impl.DSL.unquotedName; import java.util.ArrayList; -import java.util.Collections; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; -import org.jooq.Binding; import org.jooq.Catalog; import org.jooq.Comment; -import org.jooq.Configuration; import org.jooq.Constraint; -import org.jooq.Converter; import org.jooq.DataType; import org.jooq.Field; import org.jooq.Index; @@ -61,37 +58,40 @@ import org.jooq.Query; import org.jooq.Record; import org.jooq.Schema; import org.jooq.SortField; +import org.jooq.SortOrder; import org.jooq.Table; import org.jooq.TableField; import org.jooq.UniqueKey; import org.jooq.exception.DataAccessException; import org.jooq.exception.DataDefinitionException; -import org.jooq.tools.JooqLogger; +@SuppressWarnings("serial") final class DDLInterpreter { - private final Map catalogs = new LinkedHashMap<>(); - private final Configuration configuration; + private final Map catalogs = new LinkedHashMap<>(); private final MutableCatalog defaultCatalog; private final MutableSchema defaultSchema; private MutableSchema currentSchema; - private JooqLogger log = JooqLogger.getLogger(DDLInterpreter.class); - DDLInterpreter(Configuration configuration) { - this.configuration = configuration; - defaultCatalog = new MutableCatalog(null); - catalogs.put(defaultCatalog.getUnqualifiedName(), defaultCatalog); - defaultSchema = new MutableSchema(null, defaultCatalog); + DDLInterpreter() { + defaultCatalog = new MutableCatalog(NO_NAME); + catalogs.put(defaultCatalog.name, defaultCatalog); + defaultSchema = new MutableSchema(NO_NAME, defaultCatalog); currentSchema = defaultSchema; } - Meta meta() { + final Meta meta() { return new AbstractMeta() { private static final long serialVersionUID = 2052806256506059701L; @Override protected List getCatalogs0() throws DataAccessException { - return new ArrayList<>(catalogs.values()); + List result = new ArrayList<>(); + + for (MutableCatalog catalog : catalogs.values()) + result.add(catalog.new InterpretedCatalog()); + + return result; } }; } @@ -99,6 +99,8 @@ final class DDLInterpreter { final void accept(Query query) { if (query instanceof CreateSchemaImpl) accept0((CreateSchemaImpl) query); + else if (query instanceof AlterSchemaImpl) + accept0((AlterSchemaImpl) query); else if (query instanceof DropSchemaImpl) accept0((DropSchemaImpl) query); else if (query instanceof CreateTableImpl) @@ -124,6 +126,29 @@ final class DDLInterpreter { getSchema(schema, true); } + private final void accept0(AlterSchemaImpl query) { + Schema schema = query.$schema(); + Schema renameTo = query.$renameTo(); + + MutableSchema oldSchema = getSchema(schema, false); + if (oldSchema == null) { + if (!query.$ifExists()) + throw new DataDefinitionException("Schema does not exist: " + schema.getQualifiedName()); + + return; + } + + if (renameTo != null) { + if (getSchema(renameTo, false) != null) + throw new DataDefinitionException("Schema already exists: " + renameTo.getQualifiedName()); + + oldSchema.name = (UnqualifiedName) renameTo.getUnqualifiedName(); + return; + } + else + throw new UnsupportedOperationException(query.getSQL()); + } + private final void accept0(DropSchemaImpl query) { Schema schema = query.$schema(); MutableSchema mutableSchema = getSchema(schema, false); @@ -149,48 +174,48 @@ final class DDLInterpreter { Table table = query.$table(); MutableSchema schema = getSchema(table.getSchema(), true); - if (schema.getTable(table.getUnqualifiedName()) != null) { + if (schema.getTable((UnqualifiedName) table.getUnqualifiedName()) != null) { if (!query.$ifNotExists()) throw new DataDefinitionException("Table already exists: " + table.getQualifiedName()); return; } - MutableTable t = new MutableTable(table.getUnqualifiedName(), schema, query.$comment()); + MutableTable t = new MutableTable((UnqualifiedName) table.getUnqualifiedName(), schema, query.$comment()); List> columns = query.$columnFields(); - if (!columns.isEmpty()) + if (!columns.isEmpty()) { for (int i = 0; i < columns.size(); i++) { Field column = columns.get(i); - t.addColumn(column.getUnqualifiedName(), query.$columnTypes().get(i)); + t.fields.add(new MutableField((UnqualifiedName) column.getUnqualifiedName(), t, query.$columnTypes().get(i))); } - else if (query.$select() != null) + } + else if (query.$select() != null) { for (Field column : query.$select().fields()) - t.addColumn(column.getUnqualifiedName(), column.getDataType()); + t.fields.add(new MutableField((UnqualifiedName) column.getUnqualifiedName(), t, column.getDataType())); + } - for (Constraint constraint : query.$constraints()) - if (constraint instanceof ConstraintImpl) { - ConstraintImpl impl = (ConstraintImpl) constraint; - // XXX handle case that primary key already exists? - if (impl.$primaryKey() != null) - t.addPrimaryKey(impl.getUnqualifiedName(), impl.$primaryKey()); - if (impl.$unique() != null) - t.addUniqueKey(impl.getUnqualifiedName(), impl.$unique()); - } - else - // XXX log warning? - ; - for (Index index : query.$indexes()) - if (index instanceof IndexImpl) { - IndexImpl impl = (IndexImpl) index; - t.addIndex(impl.getUnqualifiedName(), impl.$fields(), impl.$unique()); - } + for (Constraint constraint : query.$constraints()) { + ConstraintImpl impl = (ConstraintImpl) constraint; + + // XXX handle case that primary key already exists? + if (impl.$primaryKey() != null) + t.primaryKey = new MutableUniqueKey((UnqualifiedName) impl.getUnqualifiedName(), t, t.fields(impl.$primaryKey())); + + else if (impl.$unique() != null) + t.uniqueKeys.add(new MutableUniqueKey((UnqualifiedName) impl.getUnqualifiedName(), t, t.fields(impl.$unique()))); + } + + for (Index index : query.$indexes()) { + IndexImpl impl = (IndexImpl) index; + t.indexes.add(new MutableIndex((UnqualifiedName) impl.getUnqualifiedName(), t, t.sortFields(impl.$fields()), impl.$unique())); + } } private final void accept0(AlterTableImpl query) { Table table = query.$table(); MutableSchema schema = getSchema(table.getSchema(), false); - MutableTable existing = schema.getTable(table.getUnqualifiedName()); + MutableTable existing = schema.getTable((UnqualifiedName) table.getUnqualifiedName()); if (existing == null) { if (!query.$ifExists()) throw new DataDefinitionException("Table does not exist: " + table.getQualifiedName()); @@ -201,18 +226,25 @@ final class DDLInterpreter { Field addColumn = query.$addColumn(); if (addColumn != null) { if (query.$addFirst()) - existing.addColumn(addColumn.getUnqualifiedName(), query.$addColumnType(), 0); + existing.fields.add(0, new MutableField((UnqualifiedName) addColumn.getUnqualifiedName(), existing, query.$addColumnType())); else if (query.$addBefore() != null) - existing.addColumn(addColumn.getUnqualifiedName(), query.$addColumnType(), indexOrFail(existing, query.$addBefore())); + existing.fields.add(indexOrFail(existing, query.$addBefore()), new MutableField((UnqualifiedName) addColumn.getUnqualifiedName(), existing, query.$addColumnType())); else if (query.$addAfter() != null) - existing.addColumn(addColumn.getUnqualifiedName(), query.$addColumnType(), indexOrFail(existing, query.$addAfter()) + 1); + existing.fields.add(indexOrFail(existing, query.$addAfter()) + 1, new MutableField((UnqualifiedName) addColumn.getUnqualifiedName(), existing, query.$addColumnType())); else - existing.addColumn(addColumn.getUnqualifiedName(), query.$addColumnType()); + existing.fields.add(new MutableField((UnqualifiedName) addColumn.getUnqualifiedName(), existing, query.$addColumnType())); } } - private int indexOrFail(MutableTable existing, Field field) { - int result = existing.indexOf(field); + private final int indexOrFail(MutableTable existing, Field field) { + int result = -1; + + for (int i = 0; i < existing.fields.size(); i++) { + if (existing.fields.get(i).name.equals(field.getUnqualifiedName())) { + result = i; + break; + } + } if (result == -1) throw new DataDefinitionException("Field does not exist: " + field.getQualifiedName()); @@ -225,7 +257,7 @@ final class DDLInterpreter { MutableSchema schema = getSchema(table.getSchema(), false); // TODO schema == null - MutableTable existing = schema.dropTable(table.getUnqualifiedName()); + MutableTable existing = schema.dropTable((UnqualifiedName) table.getUnqualifiedName()); if (existing == null) { if (!query.$ifExists()) throw new DataDefinitionException("Table does not exist: " + table.getQualifiedName()); @@ -242,14 +274,14 @@ final class DDLInterpreter { if (input.getCatalog() != null) { Name catalogName = input.getCatalog().getUnqualifiedName(); if ((catalog = catalogs.get(catalogName)) == null && create) - catalogs.put(catalogName, catalog = new MutableCatalog(catalogName)); + catalogs.put(catalogName, catalog = new MutableCatalog((UnqualifiedName) catalogName)); } if (catalog == null) return null; MutableSchema schema = defaultSchema; - Name schemaName = input.getUnqualifiedName(); + UnqualifiedName schemaName = (UnqualifiedName) input.getUnqualifiedName(); if ((schema = catalog.getSchema(schemaName)) == null && create) // TODO createSchemaIfNotExists should probably be configurable schema = new MutableSchema(schemaName, catalog); @@ -257,183 +289,290 @@ final class DDLInterpreter { return schema; } - private static Name normalize(Name name) { + private static UnqualifiedName normalize(UnqualifiedName name) { if (name == null) return null; - if (name instanceof UnqualifiedName) { - if (name.quoted() == Quoted.QUOTED) - return name; - String lowerCase = name.first().toLowerCase(); - return name.first() == lowerCase ? name : unquotedName(lowerCase); - } - Name[] parts = name.parts(); - for (int i = 0; i < parts.length; i++) - parts[i] = normalize(parts[i]); - return DSL.name(parts); + if (name.quoted() == Quoted.QUOTED) + return name; + + String lowerCase = name.first().toLowerCase(); + return (UnqualifiedName) (name.first() == lowerCase ? name : unquotedName(lowerCase)); } - private static class MutableCatalog extends CatalogImpl { - private static final long serialVersionUID = 9061637392590064527L; + private static abstract class MutableNamed { + UnqualifiedName name; + Comment comment; - private List schemas = new ArrayList<>(); - - MutableCatalog(Name name) { - super(normalize(name)); + MutableNamed(UnqualifiedName name) { + this(name, null); + } + + MutableNamed(UnqualifiedName name, Comment comment) { + this.name = normalize(name); + this.comment = comment; } - @SuppressWarnings("unchecked") @Override - public List getSchemas() { - return Collections.unmodifiableList((List) (List) schemas); + public String toString() { + return name.toString(); + } + } + + private static final class MutableCatalog extends MutableNamed { + List schemas = new ArrayList<>(); + + MutableCatalog(UnqualifiedName name) { + super(name, null); } - MutableSchema getSchema(Name name) { + final MutableSchema getSchema(UnqualifiedName n) { for (MutableSchema schema : schemas) - if (schema.getUnqualifiedName().equals(name)) + if (schema.name.equals(n)) return schema; + return null; } + + private final class InterpretedCatalog extends CatalogImpl { + InterpretedCatalog() { + super(MutableCatalog.this.name, MutableCatalog.this.comment); + } + + @Override + public final List getSchemas() { + List result = new ArrayList<>(schemas.size()); + + for (MutableSchema schema : schemas) + result.add(schema.new InterpretedSchema(this)); + + return result; + } + } } - private static class MutableSchema extends SchemaImpl { - private static final long serialVersionUID = -6704449383643804804L; + private static final class MutableSchema extends MutableNamed { + MutableCatalog catalog; + List tables = new ArrayList<>(); - private final MutableCatalog catalog; - private final List tables = new ArrayList<>(); + MutableSchema(UnqualifiedName name, MutableCatalog catalog) { + super(name); - MutableSchema(Name name, MutableCatalog catalog) { - super(normalize(name), null); this.catalog = catalog; catalog.schemas.add(this); } - @Override - public Catalog getCatalog() { - return catalog; - } - - @Override - @SuppressWarnings({ "unchecked", "rawtypes" }) - public List> getTables() { - return Collections.unmodifiableList((List) tables); - } - - boolean isEmpty() { + final boolean isEmpty() { return tables.isEmpty(); } - MutableTable getTable(Name name) { - name = normalize(name); + final MutableTable getTable(UnqualifiedName n) { + n = normalize(n); for (MutableTable table : tables) - if (table.getUnqualifiedName().equals(name)) + if (table.name.equals(n)) return table; return null; } - MutableTable dropTable(Name name) { - name = normalize(name); + final MutableTable dropTable(UnqualifiedName n) { + n = normalize(n); for (int i = 0; i < tables.size(); i++) - if (tables.get(i).getUnqualifiedName().equals(name)) + if (tables.get(i).name.equals(n)) return tables.remove(i); return null; } + private final class InterpretedSchema extends SchemaImpl { + InterpretedSchema(MutableCatalog.InterpretedCatalog catalog) { + super(MutableSchema.this.name, catalog, MutableSchema.this.comment); + } + + @Override + public final List> getTables() { + List> result = new ArrayList<>(tables.size()); + + for (MutableTable table : tables) + result.add(table.new InterpretedTable(this)); + + return result; + } + } } - private static class MutableTable extends TableImpl { - private static final long serialVersionUID = -7474225786973716638L; + private static final class MutableTable extends MutableNamed { + MutableSchema schema; + List fields = new ArrayList<>(); + MutableUniqueKey primaryKey; + List uniqueKeys = new ArrayList<>(); + List indexes = new ArrayList<>(); - private UniqueKey primaryKey; - private List> keys; - private List indexes; + MutableTable(UnqualifiedName name, MutableSchema schema, Comment comment) { + super(name, comment); - MutableTable(Name name, MutableSchema schema, Comment comment) { - super(normalize(name), schema, null, null, comment); + this.schema = schema; schema.tables.add(this); } - void addColumn(Name name, DataType dataType) { - createField(normalize(name), dataType); + final MutableField field(Field f) { + Name n = f.getUnqualifiedName(); + + for (MutableField mf : fields) + if (mf.name.equals(n)) + return mf; + + return null; } - void addColumn(Name name, DataType dataType, int position) { - createField(normalize(name), dataType, this, null, null, null, position); - } + final List fields(Field... fs) { + List result = new ArrayList<>(); - // TODO Remove this implementation copy from AbstractTable again, replace by new - // mutable meta model, see https://github.com/jOOQ/jOOQ/issues/8528#issuecomment-530238124 - protected static final TableField createField(Name name, DataType type, Table table, String comment, Converter converter, Binding binding, int position) { - final Binding actualBinding = DefaultBinding.newBinding(converter, type, binding); - final DataType actualType = - converter == null && binding == null - ? (DataType) type - : type.asConvertedDataType(actualBinding); + for (Field f : fs) { + MutableField mf = field(f); - // [#5999] TODO: Allow for user-defined Names - final TableFieldImpl tableField = new TableFieldImpl<>(name, actualType, table, DSL.comment(comment), actualBinding); + if (mf == null) + throw new DataDefinitionException("Field does not exist in table: " + f.getQualifiedName()); - // [#1199] The public API of Table returns immutable field lists - if (table instanceof TableImpl) { - ((TableImpl) table).fields0().add(position, tableField); + result.add(mf); } - return tableField; - } - - @SuppressWarnings({ "unchecked", "rawtypes" }) - void addPrimaryKey(Name name, Field[] primaryKeyFields) { - if (primaryKeyFields != null) - this.primaryKey = new UniqueKeyImpl(this, normalize(name).first(), copiedFields(primaryKeyFields)); - } - - @SuppressWarnings({ "rawtypes", "unchecked" }) - void addUniqueKey(Name name, Field[] uniqueKeyFields) { - if (uniqueKeyFields != null) { - if (keys == null) - keys = new ArrayList<>(); - keys.add(new UniqueKeyImpl(this, normalize(name).first(), copiedFields(uniqueKeyFields))); - } - } - - void addIndex(Name name, SortField[] indexFields, boolean unique) { - // XXX copy fields? - if (indexes == null) - indexes = new ArrayList<>(); - indexes.add(Internal.createIndex(normalize(name).first(), this, indexFields, unique)); - } - - private final TableField[] copiedFields(Field[] input) { - TableField[] result = new TableField[input.length]; - for (int i = 0; i < input.length; i++) - result[i] = (TableField) field(normalize(input[i].getUnqualifiedName())); return result; } - @Override - public UniqueKey getPrimaryKey() { - return primaryKey; + final List sortFields(SortField... sfs) { + List result = new ArrayList<>(); + + for (SortField sf : sfs) { + Field f = ((SortFieldImpl) sf).getField(); + MutableField mf = field(f); + + if (mf == null) + throw new DataDefinitionException("Field does not exist in table: " + f.getQualifiedName()); + + result.add(new MutableSortField(mf, sf.getOrder())); + } + + return result; } - @SuppressWarnings({ "unchecked", "rawtypes" }) - @Override - public List> getKeys() { - if (primaryKey == null) - return keys == null ? Collections.emptyList() : Collections.unmodifiableList((List) keys); - else if (keys == null) - return Collections.singletonList(primaryKey); + private final class InterpretedTable extends TableImpl { + InterpretedTable(MutableSchema.InterpretedSchema schema) { + super(MutableTable.this.name, schema, null, null, MutableTable.this.comment); - List> result = new ArrayList<>(); - result.add(primaryKey); - result.addAll(keys); - return Collections.unmodifiableList(result); - } + for (MutableField field : MutableTable.this.fields) + createField(field.name, field.type); + } - @SuppressWarnings({ "unchecked", "rawtypes" }) - @Override - public List getIndexes() { - return indexes == null ? Collections.emptyList() : Collections.unmodifiableList((List) indexes); + @Override + public final UniqueKey getPrimaryKey() { + return interpretedKey(MutableTable.this.primaryKey); + } + + @Override + public final List> getKeys() { + List> result = new ArrayList<>(); + UniqueKey pk = getPrimaryKey(); + + if (pk != null) + result.add(pk); + + for (MutableUniqueKey uk : MutableTable.this.uniqueKeys) + result.add(interpretedKey(uk)); + + return result; + } + + @Override + public final List getIndexes() { + List result = new ArrayList<>(); + + for (MutableIndex i : MutableTable.this.indexes) + result.add(interpretedIndex(i)); + + return result; + } + + @SuppressWarnings("unchecked") + private final UniqueKey interpretedKey(MutableUniqueKey key) { + if (key == null) + return null; + + TableField[] f = new TableField[key.fields.size()]; + + for (int i = 0; i < f.length; i++) + f[i] = (TableField) field(key.fields.get(i).name); + + return new UniqueKeyImpl(this, key.name.last(), f); + } + + private final Index interpretedIndex(MutableIndex idx) { + if (idx == null) + return null; + + SortField[] f = new SortField[idx.fields.size()]; + + for (int i = 0; i < f.length; i++) { + MutableSortField msf = idx.fields.get(i); + f[i] = field(msf.name).sort(msf.sort); + } + + return new IndexImpl(idx.name, this, f, null, idx.unique); + } } } + private static abstract class MutableKey extends MutableNamed { + MutableTable table; + List fields; + + MutableKey(UnqualifiedName name, MutableTable table, List fields) { + super(name); + + this.table = table; + this.fields = fields; + } + } + + private static final class MutableUniqueKey extends MutableKey { + MutableUniqueKey(UnqualifiedName name, MutableTable table, List fields) { + super(name, table, fields); + } + } + + private static final class MutableIndex extends MutableNamed { + MutableTable table; + List fields; + boolean unique; + + MutableIndex(UnqualifiedName name, MutableTable table, List fields, boolean unique) { + super(name); + + this.table = table; + this.fields = fields; + this.unique = unique; + } + } + + private static final class MutableField extends MutableNamed { + MutableTable table; + DataType type; + + MutableField(UnqualifiedName name, MutableTable table, DataType type) { + super(name); + + this.table = table; + this.type = type; + } + } + + private static final class MutableSortField extends MutableNamed { + MutableField field; + SortOrder sort; + + MutableSortField(MutableField field, SortOrder sort) { + super(field.name); + + this.field = field; + this.sort = sort; + } + } } diff --git a/jOOQ/src/main/java/org/jooq/impl/DDLInterpreterMetaProvider.java b/jOOQ/src/main/java/org/jooq/impl/DDLInterpreterMetaProvider.java index dc5aa04f68..2f8a8de623 100644 --- a/jOOQ/src/main/java/org/jooq/impl/DDLInterpreterMetaProvider.java +++ b/jOOQ/src/main/java/org/jooq/impl/DDLInterpreterMetaProvider.java @@ -61,11 +61,10 @@ import org.jooq.tools.JooqLogger; */ final class DDLInterpreterMetaProvider implements MetaProvider { - private static final JooqLogger log = JooqLogger.getLogger(DDLInterpreterMetaProvider.class); + private static final JooqLogger log = JooqLogger.getLogger(DDLInterpreterMetaProvider.class); - // FIXME this exception is obviously a hack we need to remove again... - private final Configuration configuration; - private final Source[] scripts; + private final Configuration configuration; + private final Source[] scripts; public DDLInterpreterMetaProvider(Configuration configuration, Source... scripts) { this.configuration = configuration == null ? new DefaultConfiguration() : configuration; @@ -74,7 +73,7 @@ final class DDLInterpreterMetaProvider implements MetaProvider { @Override public Meta provide() { - final DDLInterpreter interpreter = new DDLInterpreter(configuration); + final DDLInterpreter interpreter = new DDLInterpreter(); Configuration localConfiguration = configuration.derive(); DSLContext ctx = DSL.using(localConfiguration); for (Source script : scripts) diff --git a/jOOQ/src/main/java/org/jooq/impl/Fields.java b/jOOQ/src/main/java/org/jooq/impl/Fields.java index e55c46374a..07faba39d6 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Fields.java +++ b/jOOQ/src/main/java/org/jooq/impl/Fields.java @@ -407,17 +407,6 @@ final class Fields extends AbstractQueryPart implements Record fields = result; } - // TODO: Remove this method again when no longer needed by DDLInterpreter - final void add(int i, Field f) { - Field[] result = new Field[fields.length + 1]; - - System.arraycopy(fields, 0, result, 0, i); - System.arraycopy(fields, i, result, i + 1, fields.length - i); - result[i] = f; - - fields = result; - } - // ------------------------------------------------------------------------- // XXX: [#8040] An abstraction over two possible return types. // -------------------------------------------------------------------------