Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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. */ package org.apache.openjpa.jdbc.meta; import java.io.Serializable; import java.sql.Types; import java.util.ArrayList; import java.util.Collections; import java.util.List; import org.apache.commons.lang.StringUtils; import org.apache.openjpa.jdbc.conf.JDBCConfiguration; import org.apache.openjpa.jdbc.identifier.Normalizer; import org.apache.openjpa.jdbc.identifier.DBIdentifier; import org.apache.openjpa.jdbc.identifier.QualifiedDBIdentifier; import org.apache.openjpa.jdbc.schema.Column; import org.apache.openjpa.jdbc.schema.ColumnIO; import org.apache.openjpa.jdbc.schema.ForeignKey; import org.apache.openjpa.jdbc.schema.Index; import org.apache.openjpa.jdbc.schema.PrimaryKey; import org.apache.openjpa.jdbc.schema.Schema; import org.apache.openjpa.jdbc.schema.SchemaGroup; import org.apache.openjpa.jdbc.schema.Schemas; import org.apache.openjpa.jdbc.schema.Table; import org.apache.openjpa.jdbc.schema.Unique; import org.apache.openjpa.jdbc.sql.DBDictionary; import org.apache.openjpa.lib.log.Log; import org.apache.openjpa.lib.util.Localizer; import org.apache.openjpa.lib.util.Localizer.Message; import org.apache.openjpa.meta.JavaTypes; import org.apache.openjpa.meta.MetaDataContext; import org.apache.openjpa.util.MetaDataException; import serp.util.Strings; /** * Base class storing raw mapping information; defines utility methods for * converting raw mapping information to full mapping to the schema. * * @author Abe White */ @SuppressWarnings("serial") public abstract class MappingInfo implements Serializable { public static final int JOIN_NONE = 0; public static final int JOIN_FORWARD = 1; public static final int JOIN_INVERSE = 2; private static final Object NULL = new Object(); private static final Localizer _loc = Localizer.forPackage(MappingInfo.class); private String _strategy = null; private List<Column> _cols = null; private Index _idx = null; private Unique _unq = null; private ForeignKey _fk = null; private boolean _canIdx = true; private boolean _canUnq = true; private boolean _canFK = true; private boolean _implicitRelation = false; private int _join = JOIN_NONE; private ColumnIO _io = null; /** * Mapping strategy name. */ public String getStrategy() { return _strategy; } /** * Mapping strategy name. */ public void setStrategy(String strategy) { _strategy = strategy; } /** * Raw column data. */ public List<Column> getColumns() { if (_cols == null) { return Collections.emptyList(); } return _cols; } /** * Gets the columns whose table name matches the given table name. * @deprecated */ public List<Column> getColumns(String tableName) { return getColumns(DBIdentifier.newTable(tableName)); } /** * Gets the columns whose table name matches the given table name. */ public List<Column> getColumns(DBIdentifier tableName) { if (_cols == null) return Collections.emptyList(); List<Column> result = new ArrayList<Column>(); for (Column col : _cols) { if (DBIdentifier.equal(col.getTableIdentifier(), tableName)) result.add(col); } return result; } /** * Raw column data. */ public void setColumns(List<Column> cols) { _cols = cols; } /** * Raw index. */ public Index getIndex() { return _idx; } /** * Raw index. */ public void setIndex(Index idx) { _idx = idx; } /** * The user can mark columns as explicitly non-indexable. */ public boolean canIndex() { return _canIdx; } /** * The user can mark columns as explicitly non-indexable. */ public void setCanIndex(boolean indexable) { _canIdx = indexable; } /** * Affirms if this instance represents an implicit relation. For example, a * relation expressed as the value of primary key of the related class and * not as object reference. * * @since 1.3.0 */ public boolean isImplicitRelation() { return _implicitRelation; } /** * Sets a marker to imply a logical relation that can not have any physical * manifest in the database. For example, a relation expressed as the value * of primary key of the related class and not as object reference. * Populated from @ForeignKey(implicit=true) annotation. * The mutator can only transit from false to true but not vice versa. * * @since 1.3.0 */ public void setImplicitRelation(boolean flag) { _implicitRelation |= flag; } /** * Raw foreign key information. */ public ForeignKey getForeignKey() { return _fk; } /** * Raw foreign key information. */ public void setForeignKey(ForeignKey fk) { _fk = fk; if (fk != null && _join == JOIN_NONE) _join = JOIN_FORWARD; } /** * The user can mark columns as explicitly not having a foreign key. */ public boolean canForeignKey() { return _canFK; } /** * The user can mark columns as explicitly not having a foreign key. */ public void setCanForeignKey(boolean fkable) { _canFK = fkable; } /** * Raw unique constraint information. */ public Unique getUnique() { return _unq; } /** * Raw unique constraint information. */ public void setUnique(Unique unq) { _unq = unq; } /** * The user can mark columns as explicitly not having a unique constraint. */ public boolean canUnique() { return _canUnq; } /** * The user can mark columns as explicitly not having a unique constraint. */ public void setCanUnique(boolean uniquable) { _canUnq = uniquable; } /** * I/O for the columns created by the last call to {@link #createColumns}, * or for the foreign key created by the last call to * {@link #createForeignKey}. This is also expected to be set correctly * prior to calls to {@link #syncColumns} and {@link #syncForeignKey}. */ public ColumnIO getColumnIO() { return _io; } /** * I/O for the columns created by the last call to {@link #createColumns}, * or for the foreign key created by the last call to * {@link #createForeignKey}. This is also expected to be set correctly * prior to calls to {@link #syncColumns} and {@link #syncForeignKey}. */ public void setColumnIO(ColumnIO io) { _io = io; } /** * Direction of the join that the columns of this mapping info form. This * is usually automatically set by {@link #createForeignKey}. This flag * is also expected to be set correctly prior to calls to * {@link #syncForeignKey} if the join is inversed. */ public int getJoinDirection() { return _join; } /** * Direction of the join that the columns of this mapping info form. This * is usually automatically set by {@link #createForeignKey}. This flag * is also expected to be set correctly prior to calls to * {@link #syncForeignKey} if the join is inversed. */ public void setJoinDirection(int join) { _join = join; } /** * Clear all mapping information. */ public void clear() { clear(true); } /** * Clear mapping information. * * @param canFlags whether to clear information about whether we * can place indexed, foreign keys, etc on this mapping */ protected void clear(boolean canFlags) { _strategy = null; _cols = null; _io = null; _idx = null; _unq = null; _fk = null; _join = JOIN_NONE; if (canFlags) { _canIdx = true; _canFK = true; _canUnq = true; } } /** * Copy missing info from the instance to this one. */ public void copy(MappingInfo info) { if (_strategy == null) _strategy = info.getStrategy(); if (_canIdx && _idx == null) { if (info.getIndex() != null) _idx = info.getIndex(); else _canIdx = info.canIndex(); } if (_canUnq && _unq == null) { if (info.getUnique() != null) _unq = info.getUnique(); else _canUnq = info.canUnique(); } if (_canFK && _fk == null) { if (info.getForeignKey() != null) _fk = info.getForeignKey(); else _canFK = info.canForeignKey(); } _implicitRelation = info.isImplicitRelation(); List<Column> cols = getColumns(); List<Column> icols = info.getColumns(); if (!icols.isEmpty() && (cols.isEmpty() || cols.size() == icols.size())) { if (cols.isEmpty()) cols = new ArrayList<Column>(icols.size()); for (int i = 0; i < icols.size(); i++) { if (cols.size() == i) cols.add(new Column()); ((Column) cols.get(i)).copy((Column) icols.get(i)); } setColumns(cols); } } /** * Return true if this info has columns, foreign key information, index * information, etc. */ public boolean hasSchemaComponents() { return (_cols != null && !_cols.isEmpty()) || _idx != null || _unq != null || _fk != null || !_canIdx || !_canFK || !_canUnq; } /** * Assert that the user did not supply any columns, index, unique * constraint, or foreign key for this mapping. */ public void assertNoSchemaComponents(MetaDataContext context, boolean die) { if (_cols == null || _cols.isEmpty()) { assertNoIndex(context, die); assertNoUnique(context, die); assertNoForeignKey(context, die); return; } Message msg = _loc.get("unexpected-cols", context); if (die) throw new MetaDataException(msg); context.getRepository().getLog().warn(msg); } /** * Assert that this info has the given strategy or no strategy. */ public void assertStrategy(MetaDataContext context, Object contextStrat, Object expected, boolean die) { if (contextStrat == expected) return; String strat; if (contextStrat == null) { if (_strategy == null) return; if (_strategy.equals(expected.getClass().getName())) return; if (expected instanceof Strategy && _strategy.equals(((Strategy) expected).getAlias())) return; strat = _strategy; } else if (contextStrat instanceof Strategy) strat = ((Strategy) contextStrat).getAlias(); else strat = contextStrat.getClass().getName(); Message msg = _loc.get("unexpected-strategy", context, expected, strat); if (die) throw new MetaDataException(msg); context.getRepository().getLog().warn(msg); } /** * Assert that the user did not try to place an index on this mapping. */ public void assertNoIndex(MetaDataContext context, boolean die) { if (_idx == null) return; Message msg = _loc.get("unexpected-index", context); if (die) throw new MetaDataException(msg); context.getRepository().getLog().warn(msg); } /** * Assert that the user did not try to place a unique constraint on this * mapping. */ public void assertNoUnique(MetaDataContext context, boolean die) { if (_unq == null) return; Message msg = _loc.get("unexpected-unique", context); if (die) throw new MetaDataException(msg); context.getRepository().getLog().warn(msg); } /** * Assert that the user did not try to place a foreign key on this mapping * or placed an implicit foreign key. */ public void assertNoForeignKey(MetaDataContext context, boolean die) { if (_fk == null || isImplicitRelation()) return; Message msg = _loc.get("unexpected-fk", context); if (die) throw new MetaDataException(msg); context.getRepository().getLog().warn(msg); } /** * Assert that the user did not try to join. */ public void assertNoJoin(MetaDataContext context, boolean die) { boolean join = false; if (_cols != null) { Column col; for (int i = 0; !join && i < _cols.size(); i++) { col = (Column) _cols.get(i); if (!DBIdentifier.isNull(col.getTargetIdentifier())) join = true; } } if (!join) return; Message msg = _loc.get("unexpected-join", context); if (die) throw new MetaDataException(msg); context.getRepository().getLog().warn(msg); } /** * Find or generate a table for a mapping. * * @param context the mapping that uses the table * @param def default table name provider * @param schemaName default schema if known, or null * @param given given table name * @param adapt whether we can alter the schema or mappings * @deprecated */ public Table createTable(MetaDataContext context, TableDefaults def, String schemaName, String given, boolean adapt) { return createTable(context, def, DBIdentifier.newSchema(schemaName), DBIdentifier.newTable(given), adapt); } public Table createTable(MetaDataContext context, TableDefaults def, DBIdentifier schemaName, DBIdentifier given, boolean adapt) { MappingRepository repos = (MappingRepository) context.getRepository(); if (DBIdentifier.isNull(given) && (def == null || (!adapt && !repos.getMappingDefaults().defaultMissingInfo()))) throw new MetaDataException(_loc.get("no-table", context)); if (DBIdentifier.isNull(schemaName)) schemaName = Schemas.getNewTableSchemaIdentifier((JDBCConfiguration) repos.getConfiguration()); // if no given and adapting or defaulting missing info, use template SchemaGroup group = repos.getSchemaGroup(); Schema schema = null; if (DBIdentifier.isNull(given)) { schema = group.getSchema(schemaName); if (schema == null) schema = group.addSchema(schemaName); given = def.getIdentifier(schema); } QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(given); if (DBIdentifier.isNull(path.getSchemaName())) { if (!DBIdentifier.isNull(schemaName)) { path.setSchemaName(schemaName); } } else { schemaName = path.getSchemaName(); schema = null; } // look for named table using full name and findTable, which allows // the dynamic schema factory to create the table if needed Table table = group.findTable(path); if (table != null) return table; if (!adapt) throw new MetaDataException(_loc.get("bad-table", given, context)); // named table doesn't exist; create it if (schema == null) { schema = group.getSchema(schemaName); if (schema == null) schema = group.addSchema(schemaName); } table = schema.getTable(given); if (table == null) table = schema.addTable(given); return table; } /** * Retrieve/create columns on the given table by merging the given * template information with any user-provided information. * * @param context the mapping we're retrieving columns for * @param prefix localized error message key prefix * @param tmplates template columns * @param table the table for the columns * @param adapt whether we can modify the existing mapping or schema */ protected Column[] createColumns(MetaDataContext context, String prefix, Column[] tmplates, Table table, boolean adapt) { assertTable(context, table); if (prefix == null) prefix = "generic"; // the user has to give the right number of expected columns for this // mapping, or none at all if we're adapting. can't just given one of // n columns because we don't know which of the n columns the info // applies to List<Column> given = getColumns(); if (context instanceof FieldMapping && ((FieldMapping) context).hasMapsIdCols()) given = ((FieldMapping) context).getValueInfo().getMapsIdColumns(); boolean fill = ((MappingRepository) context.getRepository()).getMappingDefaults().defaultMissingInfo(); if ((!given.isEmpty() || (!adapt && !fill)) && given.size() != tmplates.length) { // also consider when this info has columns from multiple tables given = getColumns(table.getIdentifier()); if ((!adapt && !fill) && given.size() != tmplates.length) { // try default table given = getColumns(""); if ((!adapt && !fill) && given.size() != tmplates.length) { throw new MetaDataException(_loc.get(prefix + "-num-cols", context, String.valueOf(tmplates.length), String.valueOf(given.size()))); } } } Column[] cols = new Column[tmplates.length]; _io = null; Column col; for (int i = 0; i < tmplates.length; i++) { col = (given.isEmpty()) ? null : (Column) given.get(i); cols[i] = mergeColumn(context, prefix, tmplates[i], true, col, table, adapt, fill); setIOFromColumnFlags(col, i); } return cols; } boolean canMerge(List<Column> given, Column[] templates, boolean adapt, boolean fill) { return !((!given.isEmpty() || (!adapt && !fill)) && given.size() != templates.length); } /** * Set the proper internal column I/O metadata for the given column's flags. */ private void setIOFromColumnFlags(Column col, int i) { if (col == null || (!col.getFlag(Column.FLAG_UNINSERTABLE) && !col.getFlag(Column.FLAG_UNUPDATABLE) && !col.isNotNull())) return; if (_io == null) _io = new ColumnIO(); _io.setInsertable(i, !col.getFlag(Column.FLAG_UNINSERTABLE)); _io.setUpdatable(i, !col.getFlag(Column.FLAG_UNUPDATABLE)); _io.setNullInsertable(i, !col.isNotNull()); _io.setNullUpdatable(i, !col.isNotNull()); } /** * Assert that the given table is non-null. */ private static void assertTable(MetaDataContext context, Table table) { if (table == null) throw new MetaDataException(_loc.get("unmapped", context)); } /** * Merge the given columns if possible. * * @param context the mapping we're retrieving columns for * @param prefix localized error message key prefix * @param tmplate template for expected column information * @param compat whether the existing column type must be compatible * with the type of the template column * @param given the given column information from mapping info * @param table the table for the columns * @param adapt whether we can modify the existing mapping or schema * @param fill whether to default missing column information */ protected static Column mergeColumn(MetaDataContext context, String prefix, Column tmplate, boolean compat, Column given, Table table, boolean adapt, boolean fill) { assertTable(context, table); // if not adapting must provide column name at a minimum DBIdentifier colName = (given == null) ? DBIdentifier.NULL : given.getIdentifier(); if (DBIdentifier.isNull(colName) && !adapt && !fill) throw new MetaDataException(_loc.get(prefix + "-no-col-name", context)); MappingRepository repos = (MappingRepository) context.getRepository(); DBDictionary dict = repos.getDBDictionary(); // determine the column name based on given info, or template if none; // also make sure that if the user gave a column name, he didn't try // to put the column in an unexpected table if (DBIdentifier.isNull(colName)) colName = tmplate.getIdentifier(); QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(colName); if (path.isUnqualifiedColumn()) { colName = path.getIdentifier(); } else if (!DBIdentifier.isNull(path.getObjectTableName())) { findTable(context, path.getObjectTableName(), table, null, null); colName = path.getUnqualifiedName(); } // find existing column Column col = table.getColumn(colName); if (col == null && !adapt) { // // See if column name has already been validated in a dynamic table. // If so then want to use that validated column name instead. This // should seldom if ever occur as long as the database dictionaries // are kept up-to-date. // if ((colName.getName().length() > dict.maxColumnNameLength) || dict.getInvalidColumnWordSet().contains(DBIdentifier.toUpper(colName).getName()) && !(table.getClass().getName().contains("DynamicTable"))) { colName = dict.getValidColumnName(colName, new Table()); col = table.getColumn(colName); if (col == null && !adapt) { throw new MetaDataException(_loc.get(prefix + "-bad-col-name", context, colName, table)); } } else { throw new MetaDataException(_loc.get(prefix + "-bad-col-name", context, colName, table)); } } // use information from template column by default, allowing any // user-given specifics to override it int type = tmplate.getType(); int size = tmplate.getSize(); if (type == Types.OTHER) { int precis = 0; int scale = 0; if (given != null) { precis = given.getSize(); scale = given.getDecimalDigits(); } type = dict.getJDBCType(tmplate.getJavaType(), size == -1, precis, scale, tmplate.isXML()); } boolean ttype = true; int otype = type; String typeName = tmplate.getTypeName(); Boolean notNull = null; if (tmplate.isNotNullExplicit()) notNull = (tmplate.isNotNull()) ? Boolean.TRUE : Boolean.FALSE; int decimals = tmplate.getDecimalDigits(); String defStr = tmplate.getDefaultString(); boolean autoAssign = tmplate.isAutoAssigned(); boolean relationId = tmplate.isRelationId(); boolean implicitRelation = tmplate.isImplicitRelation(); String targetField = tmplate.getTargetField(); if (given != null) { // use given type if provided, but warn if it isn't compatible with // the expected column type if (given.getType() != Types.OTHER) { ttype = false; if (compat && !given.isCompatible(type, typeName, size, decimals)) { Log log = repos.getLog(); if (log.isWarnEnabled()) log.warn(_loc.get(prefix + "-incompat-col", context, colName, Schemas.getJDBCName(type))); } otype = given.getType(); type = dict.getPreferredType(otype); } typeName = given.getTypeName(); if (given.getSize() > 0) size = given.getSize(); decimals = given.getDecimalDigits(); // leave this info as the template defaults unless the user // explicitly turns it on in the given column if (given.isNotNullExplicit()) notNull = (given.isNotNull()) ? Boolean.TRUE : Boolean.FALSE; if (given.getDefaultString() != null) defStr = given.getDefaultString(); if (given.isAutoAssigned()) autoAssign = true; if (given.isRelationId()) relationId = true; if (given.isImplicitRelation()) implicitRelation = true; } // default char column size if original type is char (test original // type rather than final type because orig might be clob, translated // to an unsized varchar, which is supported by some dbs) if (size == 0 && (otype == Types.VARCHAR || otype == Types.CHAR)) size = dict.characterColumnSize; // create column, or make sure existing column matches expected type if (col == null) { col = table.addColumn(colName); col.setType(type); } else if ((compat || !ttype) && !col.isCompatible(type, typeName, size, decimals)) { // if existing column isn't compatible with desired type, die if // can't adapt, else warn and change the existing column type Message msg = _loc.get(prefix + "-bad-col", context, Schemas.getJDBCName(type), col.getDescription()); if (!adapt) throw new MetaDataException(msg); Log log = repos.getLog(); if (log.isWarnEnabled()) log.warn(msg); col.setType(type); } else if (given != null && given.getType() != Types.OTHER) { // as long as types are compatible, set column to expected type col.setType(type); } // always set the java type and autoassign to expected values, even on // an existing column, since we don't get this from the DB if (compat) col.setJavaType(tmplate.getJavaType()); else if (col.getJavaType() == JavaTypes.OBJECT) { if (given != null && given.getJavaType() != JavaTypes.OBJECT) col.setJavaType(given.getJavaType()); else col.setJavaType(JavaTypes .getTypeCode(Schemas.getJavaType(col.getType(), col.getSize(), col.getDecimalDigits()))); } col.setAutoAssigned(autoAssign); col.setRelationId(relationId); col.setImplicitRelation(implicitRelation); col.setTargetField(targetField); // we need this for runtime, and the dynamic schema factory might // not know it, so set it even if not adapting if (defStr != null) col.setDefaultString(defStr); if (notNull != null) col.setNotNull(notNull.booleanValue()); // add other details if adapting if (adapt) { if (typeName != null) col.setTypeName(typeName); if (size != 0) col.setSize(size); if (decimals != 0) col.setDecimalDigits(decimals); } if (tmplate.hasComment()) col.setComment(tmplate.getComment()); if (tmplate.isXML()) col.setXML(tmplate.isXML()); return col; } /** * Find the table named by a column or target. * * @param context context for error messages, etc. * @param name the table name, possibly including schema * @param expected the expected table; may be null * @param inverse the possible inverse table; may be null * @param rel if we're finding the target table of a join, the * joined-to type; allows us to also look in its superclass tables */ private static Table findTable(MetaDataContext context, DBIdentifier name, Table expected, Table inverse, ClassMapping rel) { // is this the expected table? if (expected == null && rel != null) expected = rel.getTable(); if (expected != null && isTableName(name, expected)) return expected; // check for inverse if (inverse != null && isTableName(name, inverse)) return inverse; // superclass table? if (rel != null) rel = rel.getJoinablePCSuperclassMapping(); while (rel != null) { if (isTableName(name, rel.getTable())) return rel.getTable(); rel = rel.getJoinablePCSuperclassMapping(); } // none of the possible tables throw new MetaDataException(_loc.get("col-wrong-table", context, expected, name.getName())); } /** * Return whether the given name matches the given table. */ private static boolean isTableName(DBIdentifier name, Table table) { return DBIdentifier.equal(name, table.getIdentifier()) || DBIdentifier.equal(name, table.getFullIdentifier()); } /** * Retrieve/create an index on the given columns by merging the given * template information with any user-provided information. * * @param context the mapping we're retrieving an index for * @param prefix localized error message key prefix * @param tmplate template for expected index information * @param cols the indexed columns * @param adapt whether we can modify the existing mapping or schema */ protected Index createIndex(MetaDataContext context, String prefix, Index tmplate, Column[] cols, boolean adapt) { if (prefix == null) prefix = "generic"; // can't create an index if there are no cols if (cols == null || cols.length == 0) { if (_idx != null) throw new MetaDataException(_loc.get(prefix + "-no-index-cols", context)); return null; } // look for an existing index on these columns Table table = cols[0].getTable(); Index[] idxs = table.getIndexes(); Index exist = null; for (int i = 0; i < idxs.length; i++) { if (idxs[i].columnsMatch(cols)) { exist = idxs[i]; break; } } // remove existing index? if (!_canIdx) { if (exist == null) return null; if (!adapt) throw new MetaDataException(_loc.get(prefix + "-index-exists", context)); table.removeIndex(exist); return null; } // if we have an existing index, merge given info into it if (exist != null) { if (_idx != null && _idx.isUnique() && !exist.isUnique()) { if (!adapt) throw new MetaDataException(_loc.get(prefix + "-index-not-unique", context)); exist.setUnique(true); } return exist; } // if no defaults return null MappingRepository repos = (MappingRepository) context.getRepository(); boolean fill = repos.getMappingDefaults().defaultMissingInfo(); if (_idx == null && (tmplate == null || (!adapt && !fill))) return null; DBIdentifier name = DBIdentifier.NULL; boolean unq; if (_idx != null) { name = _idx.getIdentifier(); unq = _idx.isUnique(); // preserve multiple columns if they are specified in the index if (_idx.getColumns() != null && _idx.getColumns().length > 1) cols = _idx.getColumns(); } else unq = tmplate.isUnique(); // if no name provided by user info, make one if (DBIdentifier.isNull(name)) { if (tmplate != null) name = tmplate.getIdentifier(); else { name = cols[0].getIdentifier(); name = repos.getDBDictionary().getValidIndexName(name, table); } } Index idx = table.addIndex(name); idx.setUnique(unq); idx.setColumns(cols); return idx; } /** * Retrieve/create a unique constraint on the given columns by merging the * given template information with any user-provided information. * * @param context the mapping we're retrieving a constraint for * @param prefix localized error message key prefix * @param tmplate template for expected unique information * @param cols the constraint columns * @param adapt whether we can modify the existing mapping or schema */ protected Unique createUnique(MetaDataContext context, String prefix, Unique tmplate, Column[] cols, boolean adapt) { if (prefix == null) prefix = "generic"; // can't create a constraint if there are no cols if (cols == null || cols.length == 0) { if (_unq != null || tmplate != null) throw new MetaDataException(_loc.get(prefix + "-no-unique-cols", context)); return null; } // look for an existing constraint on these columns Table table = cols[0].getTable(); Unique[] unqs = table.getUniques(); Unique exist = null; for (int i = 0; i < unqs.length; i++) { if (unqs[i].columnsMatch(cols)) { exist = unqs[i]; break; } } // remove existing unique? if (!_canUnq) { if (exist == null) return null; if (!adapt) throw new MetaDataException(_loc.get(prefix + "-unique-exists", context)); table.removeUnique(exist); return null; } // no defaults; return existing constraint (if any) if (tmplate == null && _unq == null) return exist; MappingRepository repos = (MappingRepository) context.getRepository(); if (exist != null) { if (_unq != null && _unq.isDeferred() && !exist.isDeferred()) { Log log = repos.getLog(); if (log.isWarnEnabled()) log.warn(_loc.get(prefix + "-defer-unique", context)); } return exist; } // dict can't handle unique constraints? DBDictionary dict = repos.getDBDictionary(); if (_unq != null && !dict.supportsUniqueConstraints) { Log log = repos.getLog(); if (log.isWarnEnabled()) log.warn(_loc.get(prefix + "-unique-support", context)); return null; } boolean fill = repos.getMappingDefaults().defaultMissingInfo(); if (!adapt && !fill && _unq == null) return null; DBIdentifier name = DBIdentifier.NULL; boolean deferred; if (_unq != null) { name = _unq.getIdentifier(); deferred = _unq.isDeferred(); } else { name = tmplate.getIdentifier(); deferred = tmplate.isDeferred(); } if (deferred && !dict.supportsDeferredConstraints) { Log log = repos.getLog(); if (log.isWarnEnabled()) log.warn(_loc.get(prefix + "-create-defer-unique", context, dict.platform)); deferred = false; } if (DBIdentifier.isEmpty(name)) { name = cols[0].getIdentifier(); name = repos.getDBDictionary().getValidUniqueName(name, table); } Unique unq = table.addUnique(name); unq.setDeferred(deferred); unq.setColumns(cols); return unq; } /** * Retrieve/create a foreign key (possibly logical) on the given columns * by merging the given template information with any user-provided * information. * * @param context the mapping we're retrieving a key for * @param prefix localized error message key prefix * @param given the columns given by the user * @param def defaults provider * @param table the table for the key * @param cls type we're joining from * @param rel target type we're joining to * @param inversable whether the foreign key can be inversed * @param adapt whether we can modify the existing mapping or schema */ protected ForeignKey createForeignKey(MetaDataContext context, String prefix, List<Column> given, ForeignKeyDefaults def, Table table, ClassMapping cls, ClassMapping rel, boolean inversable, boolean adapt) { assertTable(context, table); if (prefix == null) prefix = "generic"; // collect the foreign key columns and their targets Object[][] joins = createJoins(context, prefix, table, cls, rel, given, def, inversable, adapt); _join = JOIN_FORWARD; // establish local table using any join between two columns; if we only // find constant joins, then keep default local table (directionless) Table local = table; Table foreign = rel.getTable(); Table tmp; boolean constant = false; boolean localSet = false; for (int i = 0; i < joins.length; i++) { if (joins[i][1] instanceof Column) { tmp = ((Column) joins[i][0]).getTable(); if (!localSet) { local = tmp; localSet = true; } else if (tmp != local) throw new MetaDataException(_loc.get(prefix + "-mult-fk-tables", context, local, tmp)); foreign = ((Column) joins[i][1]).getTable(); if (joins[i][2] == Boolean.TRUE) _join = JOIN_INVERSE; } else constant = true; } // if this is not a constant join, look for existing foreign key // on local columns ForeignKey exist = null; if (!constant && local.getForeignKeys().length > 0) { Column[] cols = new Column[joins.length]; Column[] pks = new Column[joins.length]; for (int i = 0; i < joins.length; i++) { cols[i] = (Column) joins[i][0]; pks[i] = (Column) joins[i][1]; } ForeignKey[] fks = local.getForeignKeys(); for (int i = 0; i < fks.length; i++) { if (fks[i].getConstantColumns().length == 0 && fks[i].getConstantPrimaryKeyColumns().length == 0 && fks[i].columnsMatch(cols, pks)) { exist = fks[i]; break; } } } MappingRepository repos = (MappingRepository) context.getRepository(); DBDictionary dict = repos.getDBDictionary(); if (exist != null) { // make existing key logical? if (!_canFK) { if (exist.getDeleteAction() != ForeignKey.ACTION_NONE && !adapt) throw new MetaDataException(_loc.get(prefix + "-fk-exists", context)); exist.setDeleteAction(ForeignKey.ACTION_NONE); } if (_fk != null && _fk.isDeferred() && !exist.isDeferred()) { Log log = repos.getLog(); if (log.isWarnEnabled()) log.warn(_loc.get(prefix + "-defer-fk", context)); } // allow user-given info to override existing key if we're adapting; // template info cannot override existing key if (adapt && _fk != null) { if (_fk.getUpdateAction() != ForeignKey.ACTION_NONE) exist.setUpdateAction(_fk.getUpdateAction()); if (_fk.getDeleteAction() != ForeignKey.ACTION_NONE) exist.setDeleteAction(_fk.getDeleteAction()); } setIOFromJoins(exist, joins); return exist; } DBIdentifier name = DBIdentifier.NULL; int delAction = ForeignKey.ACTION_NONE; int upAction = ForeignKey.ACTION_NONE; boolean deferred = false; boolean fill = repos.getMappingDefaults().defaultMissingInfo(); ForeignKey tmplate = (def == null) ? null : def.get(local, foreign, _join == JOIN_INVERSE); if (_fk != null && (tmplate == null || (!adapt && !fill))) { // if not adapting or no template info use given data name = _fk.getIdentifier(); delAction = _fk.getDeleteAction(); upAction = _fk.getUpdateAction(); deferred = _fk.isDeferred(); } else if (_canFK && (adapt || fill)) { if (_fk == null && tmplate != null) { // no user given info; use template data name = tmplate.getIdentifier(); delAction = tmplate.getDeleteAction(); upAction = tmplate.getUpdateAction(); deferred = tmplate.isDeferred(); } else if (_fk != null && tmplate != null) { // merge user and template data, always letting user info win name = _fk.getIdentifier(); if (DBIdentifier.isNull(name) && !DBIdentifier.isNull(tmplate.getIdentifier())) name = tmplate.getIdentifier(); delAction = _fk.getDeleteAction(); if (delAction == ForeignKey.ACTION_NONE) delAction = tmplate.getDeleteAction(); upAction = _fk.getUpdateAction(); if (upAction == ForeignKey.ACTION_NONE) upAction = tmplate.getUpdateAction(); deferred = _fk.isDeferred(); } } if (!dict.supportsDeleteAction(delAction) || !dict.supportsUpdateAction(upAction)) { Log log = repos.getLog(); if (log.isWarnEnabled()) log.warn(_loc.get(prefix + "-unsupported-fk-action", context)); delAction = ForeignKey.ACTION_NONE; upAction = ForeignKey.ACTION_NONE; } if (deferred && !dict.supportsDeferredConstraints) { Log log = repos.getLog(); if (log.isWarnEnabled()) log.warn(_loc.get(prefix + "-create-defer-fk", context, dict.platform)); deferred = false; } // create foreign key with merged info ForeignKey fk = local.addForeignKey(name); fk.setDeleteAction(delAction); fk.setUpdateAction(upAction); fk.setDeferred(deferred); // add joins to key Column col; for (int i = 0; i < joins.length; i++) { col = (Column) joins[i][0]; if (joins[i][1] instanceof Column) fk.join(col, (Column) joins[i][1]); else if ((joins[i][2] == Boolean.TRUE) != (_join == JOIN_INVERSE)) fk.joinConstant(joins[i][1], col); else fk.joinConstant(col, joins[i][1]); } setIOFromJoins(fk, joins); return fk; } /** * Use the join information to populate our internal column I/O data. */ private void setIOFromJoins(ForeignKey fk, Object[][] joins) { List<Column> cols = getColumns(); _io = null; if (cols.isEmpty()) return; int constIdx = 0; int idx; for (int i = 0; i < joins.length; i++) { // const columns are indexed after std join columns in fk IO if (joins[i][1] instanceof Column) idx = i - constIdx; else if ((joins[i][2] == Boolean.TRUE) == (_join == JOIN_INVERSE)) idx = fk.getColumns().length + constIdx++; else continue; setIOFromColumnFlags((Column) cols.get(i), idx); } } /** * Create or retrieve the foreign key joins. * * @param context the mapping we're retrieving a key for * @param prefix localized error message key prefix * @param table the table for the key * @param cls type we're joining from, if applicable * @param rel target type we're joining to * @param given the columns given by the user * @param def foreign key defaults provider * @param inversable whether the foreign key can be inversed * @param adapt whether we can modify the existing mapping or schema * @return array of tuples where the first element is the * local column (or in the case of a constant join the * sole column), the second is the target column (or * constant), and the third is {@link Boolean#TRUE} if * this is an inverse join */ private Object[][] createJoins(MetaDataContext context, String prefix, Table table, ClassMapping cls, ClassMapping rel, List<Column> given, ForeignKeyDefaults def, boolean inversable, boolean adapt) { MappingRepository repos = (MappingRepository) context.getRepository(); boolean fill = repos.getMappingDefaults().defaultMissingInfo(); Object[][] joins; // if no columns given, just create mirrors of target columns if (given.isEmpty()) { if (!adapt && !fill) throw new MetaDataException(_loc.get(prefix + "-no-fk-cols", context)); Column[] targets = rel.getPrimaryKeyColumns(); joins = new Object[targets.length][3]; Column tmplate; for (int i = 0; i < targets.length; i++) { tmplate = new Column(); tmplate.setIdentifier(targets[i].getIdentifier()); tmplate.setJavaType(targets[i].getJavaType()); tmplate.setType(targets[i].getType()); tmplate.setTypeName(targets[i].getTypeName()); tmplate.setSize(targets[i].getSize()); tmplate.setDecimalDigits(targets[i].getDecimalDigits()); if (def != null) def.populate(table, rel.getTable(), tmplate, targets[i], false, i, targets.length); joins[i][0] = mergeColumn(context, prefix, tmplate, true, null, table, adapt, fill); joins[i][1] = targets[i]; } return joins; } // use given columns to create join. we don't try to use any of the // template columns, even if the user doesn't give a column linking to // every primary key of the target type -- users are allowed to create // partial joins. this means, though, that if a user wants to specify // info for one join column, he has to at least create elements for // all of them joins = new Object[given.size()][3]; Column col; for (int i = 0; i < joins.length; i++) { col = (Column) given.get(i); mergeJoinColumn(context, prefix, col, joins, i, table, cls, rel, def, inversable && !col.getFlag(Column.FLAG_PK_JOIN), adapt, fill); } return joins; } /** * Create or retrieve a foreign key column for a join. * * @param context the mapping we're retrieving a key for * @param prefix localized error message key prefix * @param given the given local foreign key column * @param joins array of joins * @param idx index of the join array to populate * @param table the table for the key * @param cls the type we're joining from * @param rel target type we're joining to * @param def foreign key defaults provider; * use null to mirror target column names * @param inversable whether the foreign key can be inversed * @param adapt whether we can modify the existing mapping or schema * @param fill whether to default missing column information */ private void mergeJoinColumn(MetaDataContext context, String prefix, Column given, Object[][] joins, int idx, Table table, ClassMapping cls, ClassMapping rel, ForeignKeyDefaults def, boolean inversable, boolean adapt, boolean fill) { // default to the primary key column name if this is a pk join DBIdentifier name = given.getIdentifier(); if (DBIdentifier.isNull(name) && given.getFlag(Column.FLAG_PK_JOIN) && cls != null) { Column[] pks = cls.getPrimaryKeyColumns(); if (pks.length == 1) name = pks[0].getIdentifier(); } // if we can't adapt, then the user must at least give a column name if (DBIdentifier.isNull(name) && !adapt && !fill) throw new MetaDataException(_loc.get(prefix + "-no-fkcol-name", context)); // check to see if the column isn't in the expected table; it might // be an inverse join or a join to a base class of the target type Table local = table; Table foreign = rel.getTable(); boolean fullName = false; boolean inverse = false; if (!DBIdentifier.isNull(name)) { QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(name); if (!DBIdentifier.isNull(path.getObjectTableName())) { if (DBIdentifier.isEmpty(path.getObjectTableName())) local = foreign; else local = findTable(context, path.getObjectTableName(), local, foreign, null); fullName = true; name = path.getIdentifier().getUnqualifiedName(); // if inverse join, then swap local and foreign tables if (local != table) { foreign = table; inverse = true; } } } boolean forceInverse = !fullName && _join == JOIN_INVERSE; if (forceInverse) { local = foreign; foreign = table; inverse = true; } // determine target DBIdentifier targetName = given.getTargetIdentifier(); Object target = null; Table ttable = null; boolean constant = false; boolean fullTarget = false; if (DBIdentifier.isNull(targetName) && given.getTargetField() != null) { ClassMapping tcls = (inverse) ? cls : rel; String fieldName = given.getTargetField(); String[] names = Normalizer.splitName(fieldName); fullTarget = names.length > 1; if (names.length > 1 && StringUtils.isEmpty(names[0])) { // allow use of '.' without prefix to mean "use expected local // cls"; but if we already inversed no need to switch again if (!inverse) tcls = cls; fieldName = names[1]; } else if (names.length > 1) { // must be class + field name tcls = findClassMapping(context, names[0], cls, rel); fieldName = names[1]; } if (tcls == null) throw new MetaDataException(_loc.get(prefix + "-bad-fktargetcls", context, fieldName, name)); FieldMapping field = tcls.getFieldMapping(fieldName); if (field == null) throw new MetaDataException( _loc.get(prefix + "-bad-fktargetfield", new Object[] { context, fieldName, name, tcls })); if (field.getColumns().length != 1) throw new MetaDataException(_loc.get(prefix + "-fktargetfield-cols", context, fieldName, name)); ttable = (field.getJoinForeignKey() != null) ? field.getTable() : field.getDefiningMapping().getTable(); targetName = field.getColumns()[0].getIdentifier(); } else if (!DBIdentifier.isNull(targetName)) { String targetNameStr = targetName.getName(); if (targetNameStr.charAt(0) == '\'') { constant = true; target = targetNameStr.substring(1, targetNameStr.length() - 1); } else if (targetNameStr.charAt(0) == '-' || targetNameStr.charAt(0) == '.' || Character.isDigit(targetNameStr.charAt(0))) { constant = true; try { if (targetNameStr.indexOf('.') == -1) target = new Integer(targetNameStr); else target = new Double(targetNameStr); } catch (RuntimeException re) { throw new MetaDataException(_loc.get(prefix + "-bad-fkconst", context, targetName, name)); } } else if ("null".equalsIgnoreCase(targetNameStr)) constant = true; else { QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(targetName); fullTarget = (!DBIdentifier.isNull(path.getObjectTableName())); if (!DBIdentifier.isNull(path.getObjectTableName()) && DBIdentifier.isEmpty(path.getObjectTableName())) { // allow use of '.' without prefix to mean "use expected // local table", but ignore if we're already inversed if (!inverse) ttable = local; targetName = path.getIdentifier().getUnqualifiedName(); } else if (!DBIdentifier.isNull(path.getObjectTableName())) { ttable = findTable(context, path.getObjectTableName(), foreign, local, (inverse) ? cls : rel); targetName = path.getIdentifier().getUnqualifiedName(); } } } // use explicit target table if available if (ttable == local && local != foreign) { // swap, unless user gave incompatible table in column name if (fullName) throw new MetaDataException(_loc.get(prefix + "-bad-fktarget-inverse", new Object[] { context, name, foreign, ttable })); local = foreign; foreign = ttable; } else if (ttable != null) { // ttable might be a table of a base class of the target foreign = ttable; } // check to see if we inversed; if this is a same-table join, then // consider it an implicit inverse if the user includes the table name // in the column name, but not in the column target, or if the user // gives no column name but a full target name inverse = inverse || local != table || (local == foreign && ((fullName && !fullTarget) || (DBIdentifier.isNull(name) && fullTarget))); if (!inversable && !constant && inverse) { if (local == foreign) throw new MetaDataException(_loc.get(prefix + "-bad-fk-self-inverse", context, local)); throw new MetaDataException(_loc.get(prefix + "-bad-fk-inverse", context, local, table)); } if (DBIdentifier.isNull(name) && constant) throw new MetaDataException(_loc.get(prefix + "-no-fkcol-name-adapt", context)); if (DBIdentifier.isNull(name) && DBIdentifier.isNull(targetName)) { // if no name or target is provided and there's more than one likely // join possibility, too ambiguous PrimaryKey pk = foreign.getPrimaryKey(); if (joins.length != 1 || pk == null || pk.getColumns().length != 1) throw new MetaDataException(_loc.get(prefix + "-no-fkcol-name-adapt", context)); // assume target is pk column targetName = pk.getColumns()[0].getIdentifier(); } else if (!DBIdentifier.isNull(name) && DBIdentifier.isNull(targetName)) { // if one primary key column use it for target; if multiple joins // look for a foreign column with same name as local column PrimaryKey pk = foreign.getPrimaryKey(); if (joins.length == 1 && pk != null && pk.getColumns().length == 1) { targetName = pk.getColumns()[0].getIdentifier(); } else if (foreign.getColumn(name) != null) { targetName = name; } else { throw new MetaDataException(_loc.get(prefix + "-no-fkcol-target-adapt", context, name)); } } // find the target column, and create template for local column based // on it Column tmplate = new Column(); tmplate.setIdentifier(name); if (!constant) { Column tcol = foreign.getColumn(targetName, false); if (tcol == null) { String schemaCase = rel.getMappingRepository().getDBDictionary().schemaCase; if (DBDictionary.SCHEMA_CASE_LOWER.equals(schemaCase)) { tcol = foreign.getColumn(DBIdentifier.toLower(targetName, true), false); } else if (DBDictionary.SCHEMA_CASE_UPPER.equals(schemaCase)) { tcol = foreign.getColumn(DBIdentifier.toUpper(targetName, true), false); } } if (tcol == null) { // give up throw new MetaDataException( _loc.get(prefix + "-bad-fktarget", new Object[] { context, targetName, name, foreign })); } if (DBIdentifier.isNull(name)) tmplate.setIdentifier(tcol.getIdentifier()); tmplate.setJavaType(tcol.getJavaType()); tmplate.setType(tcol.getType()); tmplate.setTypeName(tcol.getTypeName()); tmplate.setSize(tcol.getSize()); tmplate.setDecimalDigits(tcol.getDecimalDigits()); target = tcol; } else if (target instanceof String) tmplate.setJavaType(JavaTypes.STRING); else if (target instanceof Integer) tmplate.setJavaType(JavaTypes.INT); else if (target instanceof Double) tmplate.setJavaType(JavaTypes.DOUBLE); // populate template, but let user-given name override default name if (def != null) def.populate(local, foreign, tmplate, target, inverse, idx, joins.length); if (!DBIdentifier.isNull(name)) tmplate.setIdentifier(name); // create or merge local column Column col = mergeColumn(context, prefix, tmplate, true, given, local, adapt, fill); joins[idx][0] = col; joins[idx][1] = target; if (inverse) joins[idx][2] = Boolean.TRUE; } /** * Find the target class mapping given the user's class name. * * @param context for error messages * @param clsName class name given by user * @param cls original source mapping * @param rel original target mapping */ private static ClassMapping findClassMapping(MetaDataContext context, String clsName, ClassMapping cls, ClassMapping rel) { if (isClassMappingName(clsName, cls)) return cls; if (isClassMappingName(clsName, rel)) return rel; throw new MetaDataException(_loc.get("target-wrong-cls", new Object[] { context, clsName, cls, rel })); } /** * Return whether the given name matches the given mapping. */ private static boolean isClassMappingName(String name, ClassMapping cls) { if (cls == null) return false; if (name.equals(cls.getDescribedType().getName()) || name.equals(Strings.getClassName(cls.getDescribedType()))) return true; return isClassMappingName(name, cls.getPCSuperclassMapping()); } /** * Sets internal column information to match the given mapped columns. * * @param forceJDBCType whether to force the jdbc-type of the columns * to be set, even when it matches the default for the columns' java type */ protected void syncColumns(MetaDataContext context, Column[] cols, boolean forceJDBCType) { if (cols == null || cols.length == 0) _cols = null; else { _cols = new ArrayList<Column>(cols.length); Column col; for (int i = 0; i < cols.length; i++) { col = syncColumn(context, cols[i], cols.length, forceJDBCType, cols[i].getTable(), null, null, false); setColumnFlagsFromIO(col, i); _cols.add(col); } } } /** * Set I/O flags on the column. */ private void setColumnFlagsFromIO(Column col, int i) { if (_io == null) return; col.setFlag(Column.FLAG_UNUPDATABLE, !_io.isUpdatable(i, false)); col.setFlag(Column.FLAG_UNINSERTABLE, !_io.isInsertable(i, false)); } /** * Sets internal index information to match given mapped index. */ protected void syncIndex(MetaDataContext context, Index idx) { if (idx == null) { _idx = null; return; } _canIdx = true; _idx = new Index(); _idx.setIdentifier(idx.getIdentifier()); _idx.setUnique(idx.isUnique()); if (idx.getColumns() != null && idx.getColumns().length > 1) _idx.setColumns(idx.getColumns()); } /** * Sets internal constraint information to match given mapped constraint. */ protected void syncUnique(MetaDataContext context, Unique unq) { if (unq == null) { _unq = null; return; } _canUnq = true; _unq = new Unique(); _unq.setIdentifier(unq.getIdentifier()); _unq.setDeferred(unq.isDeferred()); } /** * Sets internal constraint and column information to match given mapped * constraint. * * @param local default local table * @param target default target table */ protected void syncForeignKey(MetaDataContext context, ForeignKey fk, Table local, Table target) { if (fk == null) { _fk = null; _cols = null; _join = JOIN_NONE; return; } if (_join == JOIN_NONE) _join = JOIN_FORWARD; if (fk.isLogical()) _fk = null; else { _canFK = true; _fk = new ForeignKey(); _fk.setIdentifier(fk.getIdentifier()); _fk.setDeleteAction(fk.getDeleteAction()); _fk.setUpdateAction(fk.getUpdateAction()); _fk.setDeferred(fk.isDeferred()); } Column[] cols = fk.getColumns(); Column[] pkCols = fk.getPrimaryKeyColumns(); Column[] ccols = fk.getConstantColumns(); Object[] cs = fk.getConstants(); Column[] cpkCols = fk.getConstantPrimaryKeyColumns(); Object[] cpks = fk.getPrimaryKeyConstants(); int size = cols.length + ccols.length + cpkCols.length; _cols = new ArrayList<Column>(size); Column col; for (int i = 0; i < cols.length; i++) { col = syncColumn(context, cols[i], size, false, local, target, pkCols[i], _join == JOIN_INVERSE); setColumnFlagsFromIO(col, i); _cols.add(col); } Object constant; for (int i = 0; i < ccols.length; i++) { constant = (cs[i] == null) ? NULL : cs[i]; col = syncColumn(context, ccols[i], size, false, local, target, constant, _join == JOIN_INVERSE); setColumnFlagsFromIO(col, cols.length + i); _cols.add(col); } for (int i = 0; i < cpkCols.length; i++) { constant = (cpks[i] == null) ? NULL : cpks[i]; _cols.add(syncColumn(context, cpkCols[i], size, false, target, local, constant, _join != JOIN_INVERSE)); } } /** * Create a copy of the given column with the raw mapping information * set correctly, and without settings that match defaults. * * @param num the number of columns for this mapping * @param forceJDBCType whether the jdbc-type of the created column * should be set, even if it matches the default * for the given column's java type * @param colTable expected table for the column * @param targetTable expected target table for join column * @param target target column or object for join column; for a * constant null target, use {@link #NULL} * @param inverse whether join column is for inverse join */ protected static Column syncColumn(MetaDataContext context, Column col, int num, boolean forceJDBCType, Table colTable, Table targetTable, Object target, boolean inverse) { // use full name for cols that aren't in the expected table, or that // are inverse joins DBDictionary dict = ((MappingRepository) context.getRepository()).getDBDictionary(); Column copy = new Column(); if (col.getTable() != colTable || inverse) copy.setIdentifier(QualifiedDBIdentifier.newPath(dict.getFullIdentifier(col.getTable(), true), col.getIdentifier())); else copy.setIdentifier(col.getIdentifier()); // set target if not default if (target != null) { if (target == NULL) copy.setTargetIdentifier(DBIdentifier.newColumn("null")); else if (target instanceof Column) { Column tcol = (Column) target; if ((!inverse && tcol.getTable() != targetTable) || (inverse && tcol.getTable() != colTable)) copy.setTargetIdentifier(QualifiedDBIdentifier .newPath(dict.getFullIdentifier(tcol.getTable(), true), tcol.getIdentifier())); else if (!defaultTarget(col, tcol, num)) copy.setTargetIdentifier(tcol.getIdentifier()); } else if (target instanceof Number) copy.setTargetIdentifier(DBIdentifier.newConstant(target.toString())); else copy.setTargetIdentifier(DBIdentifier.newConstant("'" + target + "'")); } else if (num > 1) copy.setTargetField(col.getTargetField()); if (col.getSize() != 0 && col.getSize() != dict.characterColumnSize && (col.getSize() != -1 || !col.isLob())) copy.setSize(col.getSize()); if (col.getDecimalDigits() != 0) copy.setDecimalDigits(col.getDecimalDigits()); if (col.getDefaultString() != null) copy.setDefaultString(col.getDefaultString()); if (col.isNotNull() && !col.isPrimaryKey() && (!isPrimitive(col.getJavaType()) || isForeignKey(col))) copy.setNotNull(true); // set type name if not default String typeName = col.getTypeName(); if (typeName != null || copy.getSize() != 0 || copy.getDecimalDigits() != 0) { // is this the dict default type? have to ensure jdbc-type set // prior to finding dict default copy.setType(col.getType()); String defName = dict.getTypeName(copy); copy.setType(Types.OTHER); // copy should not have size info set if it isn't used in type name boolean defSized = defName.indexOf('(') != -1; if (!defSized) { if (copy.getSize() > 0) copy.setSize(0); copy.setDecimalDigits(0); } if (typeName != null) { // make sure to strip size for comparison if (typeName.indexOf('(') == -1 && defSized) defName = defName.substring(0, defName.indexOf('(')); if (!typeName.equalsIgnoreCase(defName)) copy.setTypeName(typeName); } } // set jdbc-type if not default or if forced if (forceJDBCType || (target != null && !(target instanceof Column) && col.getType() != Types.VARCHAR) || dict.getJDBCType(col.getJavaType(), false) != col.getType()) copy.setType(col.getType()); return copy; } /** * Return whether the given column belongs to a foreign key. */ private static boolean isForeignKey(Column col) { if (col.getTable() == null) return false; ForeignKey[] fks = col.getTable().getForeignKeys(); for (int i = 0; i < fks.length; i++) if (fks[i].containsColumn(col) || fks[i].containsConstantColumn(col)) return true; return false; } /** * Return true if the given type code represents a primitive. */ private static boolean isPrimitive(int type) { switch (type) { case JavaTypes.BOOLEAN: case JavaTypes.BYTE: case JavaTypes.CHAR: case JavaTypes.DOUBLE: case JavaTypes.FLOAT: case JavaTypes.INT: case JavaTypes.LONG: case JavaTypes.SHORT: return true; default: return false; } } /** * Return true if the given target column matches the default. * If there is only one column involved in the join and it links to the * single target table pk column, or if the column name is the same as * the target column name, then the target is the default. */ private static boolean defaultTarget(Column col, Column targetCol, int num) { if (col.getIdentifier().equals(targetCol.getIdentifier())) return true; if (num > 1) return false; PrimaryKey pk = targetCol.getTable().getPrimaryKey(); if (pk == null || pk.getColumns().length != 1) return false; return targetCol == pk.getColumns()[0]; } /** * Supplies default table information. */ public static interface TableDefaults { /** * Return the default table name. * @deprecated */ public String get(Schema schema); public DBIdentifier getIdentifier(Schema schema); } /** * Supplies default foreign key information. */ public static interface ForeignKeyDefaults { /** * Return a default foreign key for the given tables, or null to * create a logical foreign key only. Do not fill in the columns of * the foreign key, only attributes like its name, delete action, etc. * Do not add the foreign key to the table. */ public ForeignKey get(Table local, Table foreign, boolean inverse); /** * Populate the given foreign key column with defaults. * * @param target the target column or constant value * @param pos the index of this column in the foreign key * @param cols the number of columns in the foreign key */ public void populate(Table local, Table foreign, Column col, Object target, boolean inverse, int pos, int cols); } }