Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.openjpa.jdbc.identifier.DBIdentifier;
import org.apache.openjpa.jdbc.identifier.QualifiedDBIdentifier;
import org.apache.openjpa.jdbc.meta.strats.FullClassStrategy;
import org.apache.openjpa.jdbc.schema.Column;
import org.apache.openjpa.jdbc.schema.ForeignKey;
import org.apache.openjpa.jdbc.schema.Index;
import org.apache.openjpa.jdbc.schema.Schema;
import org.apache.openjpa.jdbc.schema.SchemaGroup;
import org.apache.openjpa.jdbc.schema.Table;
import org.apache.openjpa.jdbc.schema.Unique;
import org.apache.openjpa.lib.meta.SourceTracker;
import org.apache.openjpa.lib.util.Localizer;
import org.apache.openjpa.lib.xml.Commentable;
import org.apache.openjpa.meta.ClassMetaData;
import org.apache.openjpa.meta.MetaDataContext;
import org.apache.openjpa.util.UserException;
/**
* Information about the mapping from a class to the schema, in raw form.
* The columns and tables used in mapping info will not be part of the
* {@link SchemaGroup} used at runtime. Rather, they will be structs
* with the relevant pieces of information filled in.
*
* @author Abe White
*/
public class ClassMappingInfo
extends MappingInfo
implements SourceTracker, Commentable {
private static final long serialVersionUID = 1L;
private static final Localizer _loc = Localizer.forPackage
(ClassMappingInfo.class);
private String _className = Object.class.getName();
private DBIdentifier _tableName = DBIdentifier.NULL;
private DBIdentifier _schemaName = DBIdentifier.NULL;
private boolean _joined = false;
private Map> _seconds = null;
private String _subStrat = null;
private File _file = null;
private int _srcType = SRC_OTHER;
private String[] _comments = null;
private int _lineNum = 0;
private int _colNum = 0;
// Unique constraints indexed by primary or secondary table name
private Map> _uniques;
private Map> _indices = new HashMap<>();
/**
* The described class name.
*/
public String getClassName() {
return _className;
}
/**
* The described class name.
*/
public void setClassName(String name) {
_className = name;
}
/**
* The default strategy for subclasses in this hierarchy.
*/
public String getHierarchyStrategy() {
return _subStrat;
}
/**
* The default strategy for subclasses in this hierarchy.
*/
public void setHierarchyStrategy(String strategy) {
_subStrat = strategy;
}
/**
* The given table name.
* @deprecated
*/
@Deprecated
public String getTableName() {
return getTableIdentifier().getName();
}
public DBIdentifier getTableIdentifier() {
return _tableName == null ? DBIdentifier.NULL : _tableName;
}
/**
* The given table name.
* @deprecated
*/
@Deprecated
public void setTableName(String table) {
setTableIdentifier(DBIdentifier.newTable(table));
}
public void setTableIdentifier(DBIdentifier table) {
_tableName = table;
}
/**
* The default schema name for unqualified tables.
* @deprecated
*/
@Deprecated
public String getSchemaName() {
return getSchemaIdentifier().getName();
}
public DBIdentifier getSchemaIdentifier() {
return _schemaName == null ? DBIdentifier.NULL : _schemaName;
}
/**
* The default schema name for unqualified tables.
* @deprecated
*/
@Deprecated
public void setSchemaName(String schema) {
setSchemaIdentifier(DBIdentifier.newSchema(schema));
}
public void setSchemaIdentifier(DBIdentifier schema) {
_schemaName = schema;
}
/**
* Whether there is a join to the superclass table.
*/
public boolean isJoinedSubclass() {
return _joined;
}
/**
* Whether there is a join to the superclass table.
*/
public void setJoinedSubclass(boolean joined) {
_joined = joined;
}
/**
* Return the class-level joined tables.
* @deprecated
*/
@Deprecated
public String[] getSecondaryTableNames() {
if (_seconds == null)
return new String[0];
return DBIdentifier.toStringArray(_seconds.keySet().toArray(new DBIdentifier[]{ }));
}
public DBIdentifier[] getSecondaryTableIdentifiers() {
if (_seconds == null)
return new DBIdentifier[0];
return _seconds.keySet().toArray(new DBIdentifier[_seconds.size()]);
}
/**
* We allow fields to reference class-level joins using just the table
* name, whereas the class join might have schema, etc information.
* This method returns the name of the given table as listed in a
* class-level join, or the given name if no join exists.
* @deprecated
*/
@Deprecated
public String getSecondaryTableName(String tableName) {
return getSecondaryTableIdentifier(DBIdentifier.newTable(tableName)).getName();
}
public DBIdentifier getSecondaryTableIdentifier(DBIdentifier tableName) {
// if no secondary table joins, bad table name, exact match,
// or an already-qualified table name, nothing to do
QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(tableName);
if (_seconds == null || DBIdentifier.isNull(tableName)
|| _seconds.containsKey(tableName)
|| !DBIdentifier.isNull(path.getSchemaName()))
return tableName;
// decide which class-level join table is best match
DBIdentifier best = tableName;
int pts = 0;
DBIdentifier fullJoin = DBIdentifier.NULL;
DBIdentifier join = DBIdentifier.NULL;
for (DBIdentifier dbIdentifier : _seconds.keySet()) {
// award a caseless match without schema 2 points
fullJoin = dbIdentifier;
QualifiedDBIdentifier joinPath = QualifiedDBIdentifier.getPath(fullJoin);
if (joinPath.isUnqualifiedObject() && pts < 2 && fullJoin.equalsIgnoreCase(tableName)) {
best = fullJoin;
pts = 2;
}
else if (joinPath.isUnqualifiedObject())
continue;
// immediately return an exact match with schema
join = joinPath.getIdentifier();
if (join.equals(tableName))
return fullJoin;
// caseless match with schema worth 1 point
if (pts < 1 && join.equalsIgnoreCase(tableName)) {
best = fullJoin;
pts = 1;
}
}
return best;
}
/**
* Return any columns defined for the given class level join, or empty
* list if none.
* @deprecated
*/
@Deprecated
public List getSecondaryTableJoinColumns(String tableName) {
return getSecondaryTableJoinColumns(DBIdentifier.newTable(tableName));
}
public List getSecondaryTableJoinColumns(DBIdentifier tableName) {
if (_seconds == null || DBIdentifier.isNull(tableName)) {
return Collections.emptyList();
}
// get the columns for the join with the best match for table name
List cols = _seconds.get(getSecondaryTableIdentifier(tableName));
if (cols == null) {
// possible that given table has extra info the join table
// doesn't have; strip it
QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(tableName);
if (!DBIdentifier.isNull(path.getSchemaName())) {
tableName = path.getIdentifier();
cols = _seconds.get(getSecondaryTableIdentifier(tableName));
}
}
if (cols == null) {
return Collections.emptyList();
}
return cols;
}
/**
* Adds a Secondary table of given name to this mapping. A secondary table
* must be known before unique constraints are added to a Secondary table.
* @deprecated
*/
@Deprecated
public void addSecondaryTable(String second) {
setSecondaryTableJoinColumns(DBIdentifier.newTable(second), null);
}
public void addSecondaryTable(DBIdentifier second) {
setSecondaryTableJoinColumns(second, null);
}
/**
* Declare the given class-level join to the named (secondary) table.
* @deprecated
*/
@Deprecated
public void setSecondaryTableJoinColumns(String tableName, List cols) {
if (cols == null)
cols = Collections.emptyList();
setSecondaryTableJoinColumns(DBIdentifier.newTable(tableName), cols);
}
public void setSecondaryTableJoinColumns(DBIdentifier tableName, List cols) {
if (cols == null)
cols = Collections.emptyList();
if (_seconds == null)
_seconds = new LinkedHashMap<>();
_seconds.put(tableName, cols);
}
/**
* Return the named table for the given class.
* @deprecated
*/
@Deprecated
public Table getTable(final ClassMapping cls, String tableName,
boolean adapt) {
return getTable(cls, DBIdentifier.newTable(tableName), adapt);
}
/**
* Return the named table for the given class.
*/
public Table getTable(final ClassMapping cls, DBIdentifier tableName,
boolean adapt) {
Table t = createTable(cls, new TableDefaults() {
@Override
public String get(Schema schema) {
// delay this so that we don't do schema reflection for unique
// table name unless necessary
return cls.getMappingRepository().getMappingDefaults().
getTableName(cls, schema);
}
@Override
public DBIdentifier getIdentifier(Schema schema) {
return cls.getMappingRepository().getMappingDefaults().
getTableIdentifier(cls, schema);
}
}, _schemaName, tableName, adapt);
t.setComment(cls.getTypeAlias() == null
? cls.getDescribedType().getName()
: cls.getTypeAlias());
return t;
}
/**
* Return the primary table for the given class.
*/
public Table getTable(final ClassMapping cls, boolean adapt) {
return getTable(cls, _tableName, adapt);
}
/**
* Return the datastore identity columns for the given class, based on the
* given templates.
*/
public Column[] getDataStoreIdColumns(ClassMapping cls, Column[] tmplates,
Table table, boolean adapt) {
cls.getMappingRepository().getMappingDefaults().
populateDataStoreIdColumns(cls, table, tmplates);
return createColumns(cls, "datastoreid", tmplates, table, adapt);
}
/**
* Return the join from this class to its superclass. The table for
* this class must be set.
*/
public ForeignKey getSuperclassJoin(final ClassMapping cls, Table table,
boolean adapt) {
ClassMapping sup = cls.getJoinablePCSuperclassMapping();
if (sup == null)
return null;
ForeignKeyDefaults def = new ForeignKeyDefaults() {
@Override
public ForeignKey get(Table local, Table foreign, boolean inverse) {
return cls.getMappingRepository().getMappingDefaults().
getJoinForeignKey(cls, local, foreign);
}
@Override
public void populate(Table local, Table foreign, Column col,
Object target, boolean inverse, int pos, int cols) {
cls.getMappingRepository().getMappingDefaults().
populateJoinColumn(cls, local, foreign, col, target,
pos, cols);
}
};
return createForeignKey(cls, "superclass", getColumns(), def, table,
cls, sup, false, adapt);
}
/**
* Synchronize internal information with the mapping data for the given
* class.
*/
public void syncWith(ClassMapping cls) {
clear(false);
ClassMapping sup = cls.getMappedPCSuperclassMapping();
if (cls.getTable() != null && (sup == null
|| sup.getTable() != cls.getTable()))
_tableName = cls.getMappingRepository().getDBDictionary().
getFullIdentifier(cls.getTable(), true);
// set io before syncing cols
setColumnIO(cls.getColumnIO());
if (cls.getJoinForeignKey() != null && sup != null
&& sup.getTable() != null)
syncForeignKey(cls, cls.getJoinForeignKey(), cls.getTable(),
sup.getTable());
else if (cls.getIdentityType() == ClassMetaData.ID_DATASTORE)
syncColumns(cls, cls.getPrimaryKeyColumns(), false);
// record inheritance strategy if class does not use default strategy
// for base classes, and for all subclasses so we can be sure subsequent
// mapping runs don't think subclass is unmapped
String strat = (cls.getStrategy() == null) ? null
: cls.getStrategy().getAlias();
if (strat != null && (cls.getPCSuperclass() != null
|| !FullClassStrategy.ALIAS.equals(strat)))
setStrategy(strat);
}
@Override
public boolean hasSchemaComponents() {
return super.hasSchemaComponents() || !DBIdentifier.isNull(_tableName);
}
@Override
protected void clear(boolean canFlags) {
super.clear(canFlags);
_tableName = DBIdentifier.NULL;
}
@Override
public void copy(MappingInfo info) {
super.copy(info);
if (!(info instanceof ClassMappingInfo))
return;
ClassMappingInfo cinfo = (ClassMappingInfo) info;
if (DBIdentifier.isNull(_tableName))
_tableName = cinfo.getTableIdentifier();
if (_subStrat == null)
_subStrat = cinfo.getHierarchyStrategy();
if (cinfo._seconds != null) {
if (_seconds == null)
_seconds = new HashMap<>();
DBIdentifier key;
for (DBIdentifier dbIdentifier : cinfo._seconds.keySet()) {
key = dbIdentifier;
if (!_seconds.containsKey(key))
_seconds.put(key, cinfo._seconds.get(key));
}
}
if (cinfo._uniques != null) {
if (_uniques == null) {
_uniques = new HashMap<>();
}
for (Entry> entry : cinfo._uniques.entrySet()) {
if (!_uniques.containsKey(entry.getKey())) {
_uniques.put(entry.getKey(), entry.getValue());
}
}
}
_indices.clear();
for (Entry> entry : cinfo._indices.entrySet()) {
if (!_indices.containsKey(entry.getKey())) {
_indices.put(entry.getKey(), entry.getValue());
}
}
}
/**
* Add a unique constraint for the given table.
* @param table must be primary table or secondary table name added a
* priori to this receiver.
* @param unique the unique constraint. null means no-op.
* @deprecated
*/
@Deprecated
public void addUnique(String table, Unique unique) {
addUnique(DBIdentifier.newTable(table), unique);
}
/**
* Add a unique constraint for the given table.
* @param table must be primary table or secondary table name added a
* priori to this receiver.
* @param unique the unique constraint. null means no-op.
*/
public void addUnique(DBIdentifier table, Unique unique) {
if (!DBIdentifier.equal(_tableName, table) &&
(_seconds == null || !_seconds.containsKey(table))) {
throw new UserException(_loc.get("unique-no-table",
new Object[]{table, _className, _tableName,
((_seconds == null) ? "" : _seconds.keySet())}));
}
if (unique == null)
return;
if (_uniques == null)
_uniques = new HashMap<>();
unique.setTableIdentifier(table);
List uniques = _uniques.get(table);
if (uniques == null) {
uniques = new ArrayList<>();
uniques.add(unique);
_uniques.put(table, uniques);
} else {
uniques.add(unique);
}
}
/**
* Add index for the given table.
* @param table must be primary table or secondary table name added a
* priori to this receiver.
* @param idx the index. null means no-op.
*/
public void addIndex(DBIdentifier table, Index idx) {
if (!DBIdentifier.equal(_tableName, table) &&
(_seconds == null || !_seconds.containsKey(table))) {
throw new UserException(_loc.get("index-no-table",
new Object[]{table, _className, _tableName,
((_seconds == null) ? "" : _seconds.keySet())}));
}
if (idx == null)
return;
idx.setTableIdentifier(table);
List indices = _indices.get(table);
if (indices == null) {
indices = new ArrayList<>();
indices.add(idx);
_indices.put(table, indices);
} else {
indices.add(idx);
}
}
/**
* Get the unique constraints of the given primary or secondary table.
* @deprecated
*/
@Deprecated
public Unique[] getUniques(String table) {
return getUniques(DBIdentifier.newTable(table));
}
/**
* Get the unique constraints of the given primary or secondary table.
*/
public Unique[] getUniques(DBIdentifier table) {
if (_uniques == null || _uniques.isEmpty()
|| _uniques.containsKey(table))
return new Unique[0];
List uniques = _uniques.get(table);
return uniques.toArray(new Unique[uniques.size()]);
}
/**
* Get all the unique constraints associated with both the primary and/or
* secondary tables.
*
*/
public Unique[] getUniques(MetaDataContext cm, boolean adapt) {
if (_uniques == null || _uniques.isEmpty())
return new Unique[0];
List result = new ArrayList<>();
for (DBIdentifier tableName : _uniques.keySet()) {
List uniqueConstraints = _uniques.get(tableName);
for (Unique template : uniqueConstraints) {
Column[] templateColumns = template.getColumns();
Column[] uniqueColumns = new Column[templateColumns.length];
Table table = getTable((ClassMapping)cm, tableName, adapt);
for (int i=0; i result = new ArrayList<>();
for (DBIdentifier tableName : _indices.keySet()) {
List indices = _indices.get(tableName);
for (Index template : indices) {
Column[] templateColumns = template.getColumns();
Column[] columns = new Column[templateColumns.length];
Table table = getTable((ClassMapping)cm, tableName, adapt);
for (int i = 0; i < columns.length; i++) {
DBIdentifier columnName = templateColumns[i].getIdentifier();
if (!table.containsColumn(columnName)) {
throw new UserException(_loc.get(
"index-missing-column",
new Object[]{cm, columnName, tableName,
Arrays.toString(table.getColumnNames())}));
}
Column column = table.getColumn(columnName);
columns[i] = column;
}
Index idx = createIndex(cm, "index", template, columns, adapt);
if (idx != null)
result.add(idx);
}
}
return result.toArray(new Index[result.size()]);
}
@Override
public File getSourceFile() {
return _file;
}
@Override
public Object getSourceScope() {
return null;
}
@Override
public int getSourceType() {
return _srcType;
}
public void setSource(File file, int srcType) {
_file = file;
_srcType = srcType;
}
@Override
public String getResourceName() {
return _className;
}
@Override
public String[] getComments() {
return (_comments == null) ? EMPTY_COMMENTS : _comments;
}
@Override
public void setComments(String[] comments) {
_comments = comments;
}
@Override
public int getLineNumber() {
return _lineNum;
}
public void setLineNumber(int lineNum) {
_lineNum = lineNum;
}
@Override
public int getColNumber() {
return _colNum;
}
public void setColNumber(int colNum) {
_colNum = colNum;
}
}
