/*
* 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.schema;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import org.apache.openjpa.jdbc.identifier.DBIdentifier;
import org.apache.openjpa.jdbc.identifier.QualifiedDBIdentifier;
/**
* Represents a grouping of schemas used in a database.
*
* @author Abe White
*/
@SuppressWarnings("serial")
public class SchemaGroup
extends NameSet
implements Cloneable {
private Map<DBIdentifier, Schema> _schemaMap = null;
// cache
private Schema[] _schemas = null;
/**
* Return all schemas.
*/
public Schema[] getSchemas() {
if (_schemas == null)
_schemas = (_schemaMap == null) ? new Schema[0] : (Schema[])
_schemaMap.values().toArray(new Schema[_schemaMap.size()]);
return _schemas;
}
/**
* Return the schema with the given name, or null if none.
* @deprecated
*/
public Schema getSchema(String name) {
if (_schemaMap == null)
return null;
return getSchema(DBIdentifier.toUpper(DBIdentifier.newSchema(name)));
}
public Schema getSchema(DBIdentifier name) {
if (_schemaMap == null)
return null;
DBIdentifier sName = DBIdentifier.toUpper(name);
Schema schema = (Schema) _schemaMap.get(sName);
return schema;
}
/**
* Add a schema to the group.
*/
public Schema addSchema() {
return addSchema(DBIdentifier.NULL);
}
/**
* Add a schema to the group.
*/
public Schema addSchema(DBIdentifier name) {
addName(name, false);
Schema schema = newSchema(name);
DBIdentifier sName = DBIdentifier.toUpper(name);
if (_schemaMap == null)
_schemaMap = new HashMap<DBIdentifier, Schema>();
_schemaMap.put(sName, schema);
_schemas = null;
return schema;
}
/**
* @deprecated
* @param name
*/
public Schema addSchema(String name) {
return addSchema(DBIdentifier.newSchema(name));
}
/**
* Remove the given schema from the group.
*
* @return true if the schema was removed, false if not in the group
*/
public boolean removeSchema(Schema schema) {
if (schema == null)
return false;
DBIdentifier name = DBIdentifier.toUpper(schema.getIdentifier());
Schema rem = (Schema) _schemaMap.get(name);
if (schema.equals(rem)) {
_schemaMap.remove(name);
removeName(schema.getIdentifier());
_schemas = null;
schema.remove();
return true;
}
return false;
}
/**
* Import a schema from another group. Foreign keys are not imported.
*/
public Schema importSchema(Schema schema) {
if (schema == null)
return null;
Schema copy = addSchema(schema.getIdentifier());
Sequence[] seqs = schema.getSequences();
for (int i = 0; i < seqs.length; i++)
copy.importSequence(seqs[i]);
Table[] tables = schema.getTables();
Index[] idxs;
Unique[] unqs;
Table tab;
for (int i = 0; i < tables.length; i++) {
tab = copy.importTable(tables[i]);
idxs = tables[i].getIndexes();
for (int j = 0; j < idxs.length; j++)
tab.importIndex(idxs[j]);
unqs = tables[i].getUniques();
for (int j = 0; j < unqs.length; j++)
tab.importUnique(unqs[j]);
}
return copy;
}
/**
* Return true if the given table is known to exist. While
* {@link #findTable} may exhibit dynamic behavior in some schema group
* implementations, this method only returns true if the table has been
* added to this group or is known to exist in the database.
*/
public boolean isKnownTable(Table table) {
return findTable(table) != null;
}
/**
* Return true if the given table is known to exist. While
* {@link #findTable} may exhibit dynamic behavior in some schema group
* implementations, this method only returns true if the table has been
* added to this group or is known to exist in the database.
* @deprecated
*/
public boolean isKnownTable(String name) {
return findTable(name) != null;
}
public boolean isKnownTable(QualifiedDBIdentifier path) {
return findTable(path) != null;
}
/**
* Find the equivalent of the given table in this schema group. The
* given table that may have come from another schema group.
*/
public Table findTable(Table table) {
return findTable(table.getQualifiedPath());
}
/**
* Find the table with the given name in the group, using '.' as the
* catalog separator. Returns null if no table found.
* @deprecated
*/
public Table findTable(String name) {
if (name == null)
return null;
return findTable(QualifiedDBIdentifier.getPath(DBIdentifier.newTable(name)));
}
public Table findTable(QualifiedDBIdentifier path) {
if (DBIdentifier.isNull(path)) {
return null;
}
if (!DBIdentifier.isNull(path.getSchemaName())) {
Schema schema = getSchema(path.getSchemaName());
if (schema != null)
return schema.getTable(path.getUnqualifiedName());
} else {
Schema[] schemas = getSchemas();
Table tab;
for (int i = 0; i < schemas.length; i++) {
tab = schemas[i].getTable(path.getIdentifier());
if (tab != null)
return tab;
}
}
return null;
}
/**
* Find the table with the given name in the group, using '.' as the catalog
* separator. Returns null if no table found.
* @deprecated
*/
public Table findTable(Schema inSchema, String name) {
if (name == null)
return null;
return findTable(inSchema, DBIdentifier.newTable(name), DBIdentifier.NULL);
}
public Table findTable(Schema inSchema, DBIdentifier name) {
if (DBIdentifier.isNull(name))
return null;
return findTable(inSchema, QualifiedDBIdentifier.getPath(name), DBIdentifier.NULL);
}
public Table findTable(Schema inSchema, DBIdentifier name, DBIdentifier defaultSchemaName) {
if (DBIdentifier.isNull(name))
return null;
return findTable(inSchema, QualifiedDBIdentifier.getPath(name), defaultSchemaName);
}
public Table findTable(Schema inSchema, QualifiedDBIdentifier path, DBIdentifier defaultSchemaName) {
if (path == null)
return null;
if (!DBIdentifier.isNull(path.getSchemaName())) {
Schema schema = getSchema(path.getSchemaName());
if (schema != null)
return schema.getTable(path.getIdentifier());
} else {
Schema[] schemas = getSchemas();
for (int i = 0; i < schemas.length; i++) {
Table tab = schemas[i].getTable(path.getIdentifier());
// if a table is found and it has the same schema
// as the input schema , it means that the table
// exists. However, if the input schema is null,
// then we assume that there is only one table for the
// db default schema, in this case, table exists..
// We can't handle the case that one entity has schema name
// and other entity does not have schema name but both entities
// map to the same table.
boolean isDefaultSchema = DBIdentifier.isNull(inSchema.getIdentifier()) &&
!DBIdentifier.isNull(defaultSchemaName) &&
DBIdentifier.equalsIgnoreCase(defaultSchemaName, schemas[i].getIdentifier());
boolean hasNoDefaultSchema = DBIdentifier.isNull(inSchema.getIdentifier()) &&
DBIdentifier.isNull(defaultSchemaName);
if (tab != null &&
(schemas[i] == inSchema || isDefaultSchema || hasNoDefaultSchema))
return tab;
}
}
return null;
}
/**
* Return true if the given sequence is known to exist. While
* {@link #findSequence} may exhibit dynamic behavior in some schema group
* implementations, this method only returns true if the sequence has been
* added to this group or is known to exist in the database.
*/
public boolean isKnownSequence(Sequence seq) {
return findSequence(seq) != null;
}
/**
* Return true if the given sequence is known to exist. While
* {@link #findSequence} may exhibit dynamic behavior in some schema group
* implementations, this method only returns true if the sequence has been
* added to this group or is known to exist in the database.
* @deprecated
*/
public boolean isKnownSequence(String name) {
return findSequence(name) != null;
}
public boolean isKnownSequence(DBIdentifier name) {
return findSequence(QualifiedDBIdentifier.getPath(name)) != null;
}
public boolean isKnownSequence(QualifiedDBIdentifier path) {
return findSequence(path) != null;
}
/**
* Find the equivalent of the given sequence in this schema group. The
* given sequence that may have come from another schema group.
*/
public Sequence findSequence(Sequence seq) {
return findSequence(seq.getQualifiedPath());
}
/**
* Find the sequence with the given name in the group, using '.' as the
* catalog separator. Returns null if no sequence found.
* @deprecated
*/
public Sequence findSequence(String name) {
if (name == null)
return null;
return findSequence(DBIdentifier.newSequence(name));
}
public Sequence findSequence(DBIdentifier name) {
if (DBIdentifier.isNull(name))
return null;
return findSequence(QualifiedDBIdentifier.getPath(name));
}
public Sequence findSequence(QualifiedDBIdentifier path) {
if (path == null)
return null;
if (!DBIdentifier.isNull(path.getSchemaName())) {
Schema schema = getSchema(path.getSchemaName());
if (schema != null)
return schema.getSequence(path.getIdentifier());
} else {
Schema[] schemas = getSchemas();
Sequence seq;
for (int i = 0; i < schemas.length; i++) {
seq = schemas[i].getSequence(path.getIdentifier());
if (seq != null)
return seq;
}
}
return null;
}
/**
* Find the sequence with the given name in the group, using '.' as the
* catalog separator. Returns null if no sequence found.
* @deprecated
*/
public Sequence findSequence(Schema inSchema, String name) {
if (name == null)
return null;
return findSequence(inSchema, QualifiedDBIdentifier.getPath(DBIdentifier.newSequence(name)));
}
public Sequence findSequence(Schema inSchema, QualifiedDBIdentifier path) {
if (path == null)
return null;
if (!DBIdentifier.isNull(path.getSchemaName())) {
Schema schema = getSchema(path.getSchemaName());
if (schema != null)
return schema.getSequence(path.getIdentifier());
} else {
Schema[] schemas = getSchemas();
Sequence seq;
for (int i = 0; i < schemas.length; i++) {
seq = schemas[i].getSequence(path.getIdentifier());
if ((seq != null) &&
(schemas[i] == inSchema || DBIdentifier.isNull(inSchema.getIdentifier())))
return seq;
}
}
return null;
}
/**
* Find all foreign keys exported by a given primary key (all foreign keys
* that link to the primary key).
*/
public ForeignKey[] findExportedForeignKeys(PrimaryKey pk) {
if (pk == null)
return new ForeignKey[0];
Schema[] schemas = getSchemas();
Table[] tabs;
ForeignKey[] fks;
Collection<ForeignKey> exports = new LinkedList<ForeignKey>();
for (int i = 0; i < schemas.length; i++) {
tabs = schemas[i].getTables();
for (int j = 0; j < tabs.length; j++) {
fks = tabs[j].getForeignKeys();
for (int k = 0; k < fks.length; k++) {
if (fks[k].getPrimaryKeyTable() != null
&& pk.equals(fks[k].getPrimaryKeyTable().
getPrimaryKey()))
exports.add(fks[k]);
}
}
}
return (ForeignKey[]) exports.toArray(new ForeignKey[exports.size()]);
}
/**
* Remove unreferenced or emtpy components from the schema.
*/
public void removeUnusedComponents() {
Schema[] schemas = getSchemas();
Table[] tabs;
Column[] cols;
Sequence[] seqs;
PrimaryKey pk;
ForeignKey[] fks;
for (int i = 0; i < schemas.length; i++) {
seqs = schemas[i].getSequences();
for (int j = 0; j < seqs.length; j++)
if (seqs[j].getRefCount() == 0)
schemas[i].removeSequence(seqs[j]);
tabs = schemas[i].getTables();
for (int j = 0; j < tabs.length; j++) {
pk = tabs[j].getPrimaryKey();
fks = tabs[j].getForeignKeys();
cols = tabs[j].getColumns();
if (pk != null && pk.getRefCount() == 0)
tabs[j].removePrimaryKey();
for (int k = 0; k < fks.length; k++)
if (fks[k].getRefCount() == 0)
tabs[j].removeForeignKey(fks[k]);
for (int k = 0; k < cols.length; k++)
if (cols[k].getRefCount() == 0)
tabs[j].removeColumn(cols[k]);
if (tabs[j].getColumns().length == 0)
schemas[i].removeTable(tabs[j]);
}
if (schemas[i].getTables().length == 0)
removeSchema(schemas[i]);
}
}
public Object clone() {
SchemaGroup clone = newInstance();
clone.copy(this);
return clone;
}
/**
* Create a new instance of this class.
*/
protected SchemaGroup newInstance() {
return new SchemaGroup();
}
/**
* Copy cloneable state from the given instance.
*/
protected void copy(SchemaGroup group) {
Schema[] schemas = group.getSchemas();
for (int i = 0; i < schemas.length; i++)
importSchema(schemas[i]);
// have to do fks after all schemas are imported
Table[] tabs;
ForeignKey[] fks;
for (int i = 0; i < schemas.length; i++) {
tabs = schemas[i].getTables();
for (int j = 0; j < tabs.length; j++) {
fks = tabs[j].getForeignKeys();
for (int k = 0; k < fks.length; k++)
getSchema(schemas[i].getIdentifier()).getTable
(tabs[j].getIdentifier()).importForeignKey(fks[k]);
}
}
}
/**
* Return a new schema with the given name.
* @deprecated
*/
protected Schema newSchema(String name) {
return new Schema(name, this);
}
protected Schema newSchema(DBIdentifier name) {
return new Schema(name, this);
}
/**
* Return a new sequence with the given name and owner schema.
* @deprecated
*/
protected Sequence newSequence(String name, Schema schema) {
return new Sequence(name, schema);
}
protected Sequence newSequence(DBIdentifier name, Schema schema) {
return new Sequence(name, schema);
}
/**
* Return a new table with the given name and owner schema.
* @deprecated
*/
protected Table newTable(String name, Schema schema) {
return new Table(name, schema);
}
protected Table newTable(DBIdentifier name, Schema schema) {
return new Table(name, schema);
}
/**
* Return a new column with the given name and owner table.
* @deprecated
*/
protected Column newColumn(String name, Table table) {
return new Column(name, table);
}
protected Column newColumn(DBIdentifier name, Table table) {
return new Column(name, table);
}
/**
* Return a new primary key with the given name and owner table.
* @deprecated
*/
protected PrimaryKey newPrimaryKey(String name, Table table) {
return new PrimaryKey(name, table);
}
protected PrimaryKey newPrimaryKey(DBIdentifier name, Table table) {
return new PrimaryKey(name, table);
}
/**
* Return a new index with the given name and owner table.
* @deprecated
*/
protected Index newIndex(String name, Table table) {
return new Index(name, table);
}
protected Index newIndex(DBIdentifier name, Table table) {
return new Index(name, table);
}
/**
* Return a new unique constraint with the given name and owner table.
* @deprecated
*/
protected Unique newUnique(String name, Table table) {
return new Unique(name, table);
}
protected Unique newUnique(DBIdentifier name, Table table) {
return new Unique(name, table);
}
/**
* Return a new foreign key with the given name and owner table.
* @deprecated
*/
protected ForeignKey newForeignKey(String name, Table table) {
return new ForeignKey(name, table);
}
protected ForeignKey newForeignKey(DBIdentifier name, Table table) {
return new ForeignKey(name, table);
}
}