| /* Copyright (c) 2001-2010, The HSQL Development Group |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * Neither the name of the HSQL Development Group nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, |
| * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| package org.hsqldb; |
| |
| import org.hsqldb.HsqlNameManager.HsqlName; |
| import org.hsqldb.error.Error; |
| import org.hsqldb.error.ErrorCode; |
| import org.hsqldb.lib.HashMappedList; |
| import org.hsqldb.lib.HsqlArrayList; |
| import org.hsqldb.lib.Iterator; |
| import org.hsqldb.lib.MultiValueHashMap; |
| import org.hsqldb.lib.OrderedHashSet; |
| import org.hsqldb.lib.StringConverter; |
| import org.hsqldb.lib.WrapperIterator; |
| import org.hsqldb.navigator.RowIterator; |
| import org.hsqldb.rights.Grantee; |
| import org.hsqldb.types.Type; |
| |
| /** |
| * Manages all SCHEMA related database objects |
| * |
| * @author Fred Toussi (fredt@users dot sourceforge.net) |
| * @version 1.9.0 |
| * @since 1.8.0 |
| */ |
| public class SchemaManager { |
| |
| Database database; |
| HsqlName defaultSchemaHsqlName; |
| HashMappedList schemaMap = new HashMappedList(); |
| MultiValueHashMap referenceMap = new MultiValueHashMap(); |
| int defaultTableType = TableBase.MEMORY_TABLE; |
| long schemaChangeTimestamp; |
| |
| public SchemaManager(Database database) { |
| |
| this.database = database; |
| defaultSchemaHsqlName = SqlInvariants.INFORMATION_SCHEMA_HSQLNAME; |
| |
| Schema schema = |
| new Schema(SqlInvariants.INFORMATION_SCHEMA_HSQLNAME, |
| SqlInvariants.INFORMATION_SCHEMA_HSQLNAME.owner); |
| |
| schemaMap.put(schema.getName().name, schema); |
| |
| try { |
| schema.typeLookup.add(SqlInvariants.CARDINAL_NUMBER); |
| schema.typeLookup.add(SqlInvariants.YES_OR_NO); |
| schema.typeLookup.add(SqlInvariants.CHARACTER_DATA); |
| schema.typeLookup.add(SqlInvariants.SQL_IDENTIFIER); |
| schema.typeLookup.add(SqlInvariants.TIME_STAMP); |
| schema.charsetLookup.add(SqlInvariants.SQL_TEXT); |
| schema.charsetLookup.add(SqlInvariants.SQL_IDENTIFIER_CHARSET); |
| schema.charsetLookup.add(SqlInvariants.SQL_CHARACTER); |
| } catch (HsqlException e) {} |
| } |
| |
| public void setSchemaChangeTimestamp() { |
| schemaChangeTimestamp = database.txManager.getGlobalChangeTimestamp(); |
| } |
| |
| public long getSchemaChangeTimestamp() { |
| return schemaChangeTimestamp; |
| } |
| |
| // pre-defined |
| public HsqlName getSQLJSchemaHsqlName() { |
| return SqlInvariants.SQLJ_SCHEMA_HSQLNAME; |
| } |
| |
| // SCHEMA management |
| public void createPublicSchema() { |
| |
| HsqlName name = database.nameManager.newHsqlName(null, |
| SqlInvariants.PUBLIC_SCHEMA, SchemaObject.SCHEMA); |
| Schema schema = new Schema(name, |
| database.getGranteeManager().getDBARole()); |
| |
| defaultSchemaHsqlName = schema.getName(); |
| |
| schemaMap.put(schema.getName().name, schema); |
| } |
| |
| /** |
| * Creates a schema belonging to the given grantee. |
| */ |
| public void createSchema(HsqlName name, Grantee owner) { |
| |
| SqlInvariants.checkSchemaNameNotSystem(name.name); |
| |
| Schema schema = new Schema(name, owner); |
| |
| schemaMap.add(name.name, schema); |
| } |
| |
| public void dropSchema(Session session, String name, boolean cascade) { |
| |
| Schema schema = (Schema) schemaMap.get(name); |
| |
| if (schema == null) { |
| throw Error.error(ErrorCode.X_42501, name); |
| } |
| |
| if (SqlInvariants.isLobsSchemaName(name)) { |
| throw Error.error(ErrorCode.X_42503, name); |
| } |
| |
| if (!cascade && !schema.isEmpty()) { |
| throw Error.error(ErrorCode.X_2B000); |
| } |
| |
| OrderedHashSet externalReferences = new OrderedHashSet(); |
| |
| getCascadingSchemaReferences(schema.getName(), externalReferences); |
| removeSchemaObjects(externalReferences); |
| |
| Iterator tableIterator = |
| schema.schemaObjectIterator(SchemaObject.TABLE); |
| |
| while (tableIterator.hasNext()) { |
| Table table = ((Table) tableIterator.next()); |
| Constraint[] list = table.getFKConstraints(); |
| |
| for (int i = 0; i < list.length; i++) { |
| Constraint constraint = list[i]; |
| |
| if (constraint.getMain().getSchemaName() != schema.getName()) { |
| constraint.getMain().removeConstraint( |
| constraint.getMainName().name); |
| } |
| } |
| |
| removeTable(session, table); |
| } |
| |
| Iterator sequenceIterator = |
| schema.schemaObjectIterator(SchemaObject.SEQUENCE); |
| |
| while (sequenceIterator.hasNext()) { |
| NumberSequence sequence = |
| ((NumberSequence) sequenceIterator.next()); |
| |
| database.getGranteeManager().removeDbObject(sequence.getName()); |
| } |
| |
| schema.clearStructures(); |
| schemaMap.remove(name); |
| |
| if (defaultSchemaHsqlName.name.equals(name)) { |
| HsqlName hsqlName = database.nameManager.newHsqlName(name, false, |
| SchemaObject.SCHEMA); |
| |
| schema = new Schema(hsqlName, |
| database.getGranteeManager().getDBARole()); |
| defaultSchemaHsqlName = schema.getName(); |
| |
| schemaMap.put(schema.getName().name, schema); |
| } |
| |
| // these are called last and in this particular order |
| database.getUserManager().removeSchemaReference(name); |
| database.getSessionManager().removeSchemaReference(schema); |
| } |
| |
| public void renameSchema(HsqlName name, HsqlName newName) { |
| |
| Schema schema = (Schema) schemaMap.get(name.name); |
| Schema exists = (Schema) schemaMap.get(newName.name); |
| |
| if (schema == null) { |
| throw Error.error(ErrorCode.X_42501, name.name); |
| } |
| |
| if (exists != null) { |
| throw Error.error(ErrorCode.X_42504, newName.name); |
| } |
| |
| SqlInvariants.checkSchemaNameNotSystem(name.name); |
| SqlInvariants.checkSchemaNameNotSystem(newName.name); |
| |
| int index = schemaMap.getIndex(name.name); |
| |
| schema.getName().rename(newName); |
| schemaMap.set(index, newName.name, schema); |
| } |
| |
| public void clearStructures() { |
| |
| Iterator it = schemaMap.values().iterator(); |
| |
| while (it.hasNext()) { |
| Schema schema = (Schema) it.next(); |
| |
| schema.clearStructures(); |
| } |
| } |
| |
| public Iterator allSchemaNameIterator() { |
| return schemaMap.keySet().iterator(); |
| } |
| |
| public HsqlName getUserSchemaHsqlName(String name) { |
| |
| Schema schema = (Schema) schemaMap.get(name); |
| |
| if (schema == null) { |
| throw Error.error(ErrorCode.X_3F000, name); |
| } |
| |
| if (schema.getName() == SqlInvariants.INFORMATION_SCHEMA_HSQLNAME) { |
| throw Error.error(ErrorCode.X_3F000, name); |
| } |
| |
| return schema.getName(); |
| } |
| |
| public Grantee toSchemaOwner(String name) { |
| |
| // Note that INFORMATION_SCHEMA and DEFINITION_SCHEMA aren't in the |
| // backing map. |
| // This may not be the most elegant solution, but it is the safest |
| // (without doing a code review for implications of adding |
| // them to the map). |
| if (SqlInvariants.INFORMATION_SCHEMA_HSQLNAME.name.equals(name)) { |
| return SqlInvariants.INFORMATION_SCHEMA_HSQLNAME.owner; |
| } |
| |
| Schema schema = (Schema) schemaMap.get(name); |
| |
| return schema == null ? null |
| : schema.getOwner(); |
| } |
| |
| public HsqlName getDefaultSchemaHsqlName() { |
| return defaultSchemaHsqlName; |
| } |
| |
| public void setDefaultSchemaHsqlName(HsqlName name) { |
| defaultSchemaHsqlName = name; |
| } |
| |
| public boolean schemaExists(String name) { |
| return SqlInvariants.INFORMATION_SCHEMA.equals(name) |
| || schemaMap.containsKey(name); |
| } |
| |
| public HsqlName findSchemaHsqlName(String name) { |
| |
| Schema schema = ((Schema) schemaMap.get(name)); |
| |
| if (schema == null) { |
| return null; |
| } |
| |
| return schema.getName(); |
| } |
| |
| /** |
| * If schemaName is null, return the default schema name, else return |
| * the HsqlName object for the schema. If schemaName does not exist, |
| * throw. |
| */ |
| public HsqlName getSchemaHsqlName(String name) { |
| |
| if (name == null) { |
| return defaultSchemaHsqlName; |
| } |
| |
| if (SqlInvariants.INFORMATION_SCHEMA.equals(name)) { |
| return SqlInvariants.INFORMATION_SCHEMA_HSQLNAME; |
| } |
| |
| Schema schema = ((Schema) schemaMap.get(name)); |
| |
| if (schema == null) { |
| throw Error.error(ErrorCode.X_3F000, name); |
| } |
| |
| return schema.getName(); |
| } |
| |
| /** |
| * Same as above, but return string |
| */ |
| public String getSchemaName(String name) { |
| return getSchemaHsqlName(name).name; |
| } |
| |
| public Schema findSchema(String name) { |
| return ((Schema) schemaMap.get(name)); |
| } |
| |
| /** |
| * Iterator includes DEFINITION_SCHEMA |
| */ |
| public Iterator fullSchemaNamesIterator() { |
| return schemaMap.keySet().iterator(); |
| } |
| |
| /** |
| * is a grantee the authorization of any schema |
| */ |
| boolean isSchemaAuthorisation(Grantee grantee) { |
| |
| Iterator schemas = allSchemaNameIterator(); |
| |
| while (schemas.hasNext()) { |
| String schemaName = (String) schemas.next(); |
| |
| if (grantee.equals(toSchemaOwner(schemaName))) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * drop all schemas with the given authorisation |
| */ |
| public void dropSchemas(Session session, Grantee grantee, |
| boolean cascade) { |
| |
| HsqlArrayList list = getSchemas(grantee); |
| Iterator it = list.iterator(); |
| |
| while (it.hasNext()) { |
| Schema schema = (Schema) it.next(); |
| |
| dropSchema(session, schema.getName().name, cascade); |
| } |
| } |
| |
| public HsqlArrayList getSchemas(Grantee grantee) { |
| |
| HsqlArrayList list = new HsqlArrayList(); |
| Iterator it = schemaMap.values().iterator(); |
| |
| while (it.hasNext()) { |
| Schema schema = (Schema) it.next(); |
| |
| if (grantee.equals(schema.getOwner())) { |
| list.add(schema); |
| } |
| } |
| |
| return list; |
| } |
| |
| public boolean hasSchemas(Grantee grantee) { |
| |
| Iterator it = schemaMap.values().iterator(); |
| |
| while (it.hasNext()) { |
| Schema schema = (Schema) it.next(); |
| |
| if (grantee.equals(schema.getOwner())) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Returns an HsqlArrayList containing references to all non-system |
| * tables and views. This includes all tables and views registered with |
| * this Database. |
| */ |
| public HsqlArrayList getAllTables() { |
| |
| Iterator schemas = allSchemaNameIterator(); |
| HsqlArrayList alltables = new HsqlArrayList(); |
| |
| while (schemas.hasNext()) { |
| String name = (String) schemas.next(); |
| |
| if (SqlInvariants.isLobsSchemaName(name)) { |
| continue; |
| } |
| |
| if (SqlInvariants.isSystemSchemaName(name)) { |
| continue; |
| } |
| |
| HashMappedList current = getTables(name); |
| |
| alltables.addAll(current.values()); |
| } |
| |
| return alltables; |
| } |
| |
| public HashMappedList getTables(String schema) { |
| |
| Schema temp = (Schema) schemaMap.get(schema); |
| |
| return temp.tableList; |
| } |
| |
| public HsqlName[] getCatalogAndBaseTableNames() { |
| |
| OrderedHashSet names = new OrderedHashSet(); |
| HsqlArrayList tables = getAllTables(); |
| |
| for (int i = 0; i < tables.size(); i++) { |
| Table table = (Table) tables.get(i); |
| |
| if (!table.isTemp()) { |
| names.add(table.getName()); |
| } |
| } |
| |
| names.add(database.getCatalogName()); |
| |
| HsqlName[] array = new HsqlName[names.size()]; |
| |
| names.toArray(array); |
| |
| return array; |
| } |
| |
| private SchemaObjectSet getSchemaObjectSet(Schema schema, int type) { |
| |
| SchemaObjectSet set = null; |
| |
| switch (type) { |
| |
| case SchemaObject.SEQUENCE : |
| set = schema.sequenceLookup; |
| break; |
| |
| case SchemaObject.TABLE : |
| case SchemaObject.VIEW : |
| set = schema.tableLookup; |
| break; |
| |
| case SchemaObject.CHARSET : |
| set = schema.charsetLookup; |
| break; |
| |
| case SchemaObject.COLLATION : |
| set = schema.collationLookup; |
| break; |
| |
| case SchemaObject.PROCEDURE : |
| set = schema.procedureLookup; |
| break; |
| |
| case SchemaObject.FUNCTION : |
| set = schema.functionLookup; |
| break; |
| |
| case SchemaObject.DOMAIN : |
| case SchemaObject.TYPE : |
| set = schema.typeLookup; |
| break; |
| |
| case SchemaObject.INDEX : |
| set = schema.indexLookup; |
| break; |
| |
| case SchemaObject.CONSTRAINT : |
| set = schema.constraintLookup; |
| break; |
| |
| case SchemaObject.TRIGGER : |
| set = schema.triggerLookup; |
| break; |
| |
| case SchemaObject.SPECIFIC_ROUTINE : |
| set = schema.specificRoutineLookup; |
| } |
| |
| return set; |
| } |
| |
| public void checkSchemaObjectNotExists(HsqlName name) { |
| |
| Schema schema = (Schema) schemaMap.get(name.schema.name); |
| SchemaObjectSet set = getSchemaObjectSet(schema, name.type); |
| |
| set.checkAdd(name); |
| } |
| |
| /** |
| * Returns the specified user-defined table or view visible within the |
| * context of the specified Session, or any system table of the given |
| * name. It excludes any temp tables created in other Sessions. |
| * Throws if the table does not exist in the context. |
| */ |
| public Table getTable(Session session, String name, String schema) { |
| |
| Table t = null; |
| |
| if (Tokens.T_MODULE.equals(schema)) { |
| t = findSessionTable(session, name, null); |
| |
| if (t == null) { |
| throw Error.error(ErrorCode.X_42501, name); |
| } |
| } |
| |
| if (schema == null) { |
| t = findSessionTable(session, name, null); |
| } |
| |
| if (t == null) { |
| schema = session.getSchemaName(schema); |
| t = findUserTable(session, name, schema); |
| } |
| |
| if (t == null) { |
| if (SqlInvariants.INFORMATION_SCHEMA.equals(schema) |
| && database.dbInfo != null) { |
| t = database.dbInfo.getSystemTable(session, name); |
| } |
| } |
| |
| if (t == null) { |
| throw Error.error(ErrorCode.X_42501, name); |
| } |
| |
| return t; |
| } |
| |
| public Table getUserTable(Session session, HsqlName name) { |
| return getUserTable(session, name.name, name.schema.name); |
| } |
| |
| /** |
| * Returns the specified user-defined table or view visible within the |
| * context of the specified Session. It excludes system tables and |
| * any temp tables created in different Sessions. |
| * Throws if the table does not exist in the context. |
| */ |
| public Table getUserTable(Session session, String name, String schema) { |
| |
| Table t = findUserTable(session, name, schema); |
| |
| if (t == null) { |
| throw Error.error(ErrorCode.X_42501, name); |
| } |
| |
| return t; |
| } |
| |
| /** |
| * Returns the specified user-defined table or view visible within the |
| * context of the specified schema. It excludes system tables. |
| * Returns null if the table does not exist in the context. |
| */ |
| public Table findUserTable(Session session, String name, |
| String schemaName) { |
| |
| Schema schema = (Schema) schemaMap.get(schemaName); |
| |
| if (schema == null) { |
| return null; |
| } |
| |
| int i = schema.tableList.getIndex(name); |
| |
| if (i == -1) { |
| return null; |
| } |
| |
| return (Table) schema.tableList.get(i); |
| } |
| |
| /** |
| * Returns the specified session context table. |
| * Returns null if the table does not exist in the context. |
| */ |
| public Table findSessionTable(Session session, String name, |
| String schemaName) { |
| return session.findSessionTable(name); |
| } |
| |
| /** |
| * Drops the specified user-defined view or table from this Database object. |
| * |
| * <p> The process of dropping a table or view includes: |
| * <OL> |
| * <LI> checking that the specified Session's currently connected User has |
| * the right to perform this operation and refusing to proceed if not by |
| * throwing. |
| * <LI> checking for referential constraints that conflict with this |
| * operation and refusing to proceed if they exist by throwing.</LI> |
| * <LI> removing the specified Table from this Database object. |
| * <LI> removing any exported foreign keys Constraint objects held by any |
| * tables referenced by the table to be dropped. This is especially |
| * important so that the dropped Table ceases to be referenced, eventually |
| * allowing its full garbage collection. |
| * <LI> |
| * </OL> |
| * |
| * <p> |
| * |
| * @param session the connected context in which to perform this operation |
| * @param table if true and if the Table to drop does not exist, fail |
| * silently, else throw |
| * @param cascade true if the name argument refers to a View |
| */ |
| public void dropTableOrView(Session session, Table table, |
| boolean cascade) { |
| |
| // ft - concurrent |
| session.commit(false); |
| |
| if (table.isView()) { |
| removeSchemaObject(table.getName(), cascade); |
| } else { |
| dropTable(session, table, cascade); |
| } |
| } |
| |
| private void dropTable(Session session, Table table, boolean cascade) { |
| |
| Schema schema = (Schema) schemaMap.get(table.getSchemaName().name); |
| int dropIndex = schema.tableList.getIndex(table.getName().name); |
| OrderedHashSet externalConstraints = |
| table.getDependentExternalConstraints(); |
| OrderedHashSet externalReferences = new OrderedHashSet(); |
| |
| getCascadingReferencingObjectNames(table.getName(), |
| externalReferences); |
| |
| if (!cascade) { |
| for (int i = 0; i < externalConstraints.size(); i++) { |
| Constraint c = (Constraint) externalConstraints.get(i); |
| HsqlName tablename = c.getRef().getName(); |
| HsqlName refname = c.getRefName(); |
| |
| if (c.getConstraintType() |
| == SchemaObject.ConstraintTypes.MAIN) { |
| throw Error.error(ErrorCode.X_42533, |
| refname.schema.name + '.' |
| + tablename.name + '.' + refname.name); |
| } |
| } |
| |
| if (!externalReferences.isEmpty()) { |
| int i = 0; |
| |
| for (; i < externalReferences.size(); i++) { |
| HsqlName name = (HsqlName) externalReferences.get(i); |
| |
| if (name.parent == table.getName()) { |
| continue; |
| } |
| |
| throw Error.error(ErrorCode.X_42502, |
| name.getSchemaQualifiedStatementName()); |
| } |
| } |
| } |
| |
| OrderedHashSet tableSet = new OrderedHashSet(); |
| OrderedHashSet constraintNameSet = new OrderedHashSet(); |
| OrderedHashSet indexNameSet = new OrderedHashSet(); |
| |
| // only columns with refs |
| OrderedHashSet childReferences = table.getReferences(); |
| SchemaObject[] triggers = table.getTriggers(); |
| |
| for (int i = 0; i < triggers.length; i++) { |
| childReferences.add(triggers[i].getName()); |
| } |
| |
| for (int i = 0; i < externalConstraints.size(); i++) { |
| Constraint c = (Constraint) externalConstraints.get(i); |
| Table t = c.getMain(); |
| |
| if (t != table) { |
| tableSet.add(t); |
| } |
| |
| t = c.getRef(); |
| |
| if (t != table) { |
| tableSet.add(t); |
| } |
| |
| constraintNameSet.add(c.getMainName()); |
| constraintNameSet.add(c.getRefName()); |
| indexNameSet.add(c.getRefIndex().getName()); |
| } |
| |
| TableWorks tw = new TableWorks(session, table); |
| |
| tableSet = tw.makeNewTables(tableSet, constraintNameSet, indexNameSet); |
| |
| tw.setNewTablesInSchema(tableSet); |
| tw.updateConstraints(tableSet, constraintNameSet); |
| removeSchemaObjects(externalReferences); |
| removeSchemaObjects(childReferences); |
| removeReferencedObject(table.getName()); |
| removeReferencingObject(table); |
| schema.tableList.remove(dropIndex); |
| schema.indexLookup.removeParent(table.getName()); |
| schema.constraintLookup.removeParent(table.getName()); |
| removeTable(session, table); |
| recompileDependentObjects(tableSet); |
| } |
| |
| private void removeTable(Session session, Table table) { |
| |
| database.getGranteeManager().removeDbObject(table.getName()); |
| table.releaseTriggers(); |
| |
| if (table.hasLobColumn()) { |
| RowIterator it = table.rowIterator(session); |
| |
| while (it.hasNext()) { |
| Row row = it.getNextRow(); |
| Object[] data = row.getData(); |
| |
| session.sessionData.adjustLobUsageCount(table, data, -1); |
| } |
| } |
| |
| database.persistentStoreCollection.releaseStore(table); |
| } |
| |
| public void setTable(int index, Table table) { |
| |
| Schema schema = (Schema) schemaMap.get(table.getSchemaName().name); |
| |
| schema.tableList.set(index, table.getName().name, table); |
| } |
| |
| /** |
| * Returns index of a table or view in the HashMappedList that |
| * contains the table objects for this Database. |
| * |
| * @param table the Table object |
| * @return the index of the specified table or view, or -1 if not found |
| */ |
| public int getTableIndex(Table table) { |
| |
| Schema schema = (Schema) schemaMap.get(table.getSchemaName().name); |
| |
| if (schema == null) { |
| return -1; |
| } |
| |
| HsqlName name = table.getName(); |
| |
| return schema.tableList.getIndex(name.name); |
| } |
| |
| public void recompileDependentObjects(OrderedHashSet tableSet) { |
| |
| OrderedHashSet set = new OrderedHashSet(); |
| |
| for (int i = 0; i < tableSet.size(); i++) { |
| Table table = (Table) tableSet.get(i); |
| |
| set.addAll(getReferencingObjectNames(table.getName())); |
| } |
| |
| Session session = database.sessionManager.getSysSession(); |
| |
| for (int i = 0; i < set.size(); i++) { |
| HsqlName name = (HsqlName) set.get(i); |
| |
| switch (name.type) { |
| |
| case SchemaObject.VIEW : |
| case SchemaObject.CONSTRAINT : |
| case SchemaObject.ASSERTION : |
| case SchemaObject.ROUTINE : |
| case SchemaObject.PROCEDURE : |
| case SchemaObject.FUNCTION : |
| case SchemaObject.SPECIFIC_ROUTINE : |
| SchemaObject object = getSchemaObject(name); |
| |
| object.compile(session, null); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * After addition or removal of columns and indexes all views that |
| * reference the table should be recompiled. |
| */ |
| public void recompileDependentObjects(Table table) { |
| |
| OrderedHashSet set = new OrderedHashSet(); |
| |
| getCascadingReferencingObjectNames(table.getName(), set); |
| |
| Session session = database.sessionManager.getSysSession(); |
| |
| for (int i = 0; i < set.size(); i++) { |
| HsqlName name = (HsqlName) set.get(i); |
| |
| switch (name.type) { |
| |
| case SchemaObject.VIEW : |
| case SchemaObject.CONSTRAINT : |
| case SchemaObject.ASSERTION : |
| case SchemaObject.ROUTINE : |
| case SchemaObject.PROCEDURE : |
| case SchemaObject.FUNCTION : |
| case SchemaObject.SPECIFIC_ROUTINE : |
| SchemaObject object = getSchemaObject(name); |
| |
| object.compile(session, null); |
| break; |
| } |
| } |
| |
| HsqlArrayList list = getAllTables(); |
| |
| for (int i = 0; i < list.size(); i++) { |
| Table t = (Table) list.get(i); |
| |
| t.verifyConstraintsIntegrity(); |
| } |
| } |
| |
| public NumberSequence getSequence(String name, String schemaName, |
| boolean raise) { |
| |
| Schema schema = (Schema) schemaMap.get(schemaName); |
| |
| if (schema != null) { |
| NumberSequence object = |
| (NumberSequence) schema.sequenceList.get(name); |
| |
| if (object != null) { |
| return object; |
| } |
| } |
| |
| if (raise) { |
| throw Error.error(ErrorCode.X_42501, name); |
| } |
| |
| return null; |
| } |
| |
| public Type getUserDefinedType(String name, String schemaName, |
| boolean raise) { |
| |
| Schema schema = (Schema) schemaMap.get(schemaName); |
| |
| if (schema != null) { |
| SchemaObject object = schema.typeLookup.getObject(name); |
| |
| if (object != null) { |
| return (Type) object; |
| } |
| } |
| |
| if (raise) { |
| throw Error.error(ErrorCode.X_42501, name); |
| } |
| |
| return null; |
| } |
| |
| public Type getDomain(String name, String schemaName, boolean raise) { |
| |
| Schema schema = (Schema) schemaMap.get(schemaName); |
| |
| if (schema != null) { |
| SchemaObject object = schema.typeLookup.getObject(name); |
| |
| if (object != null && ((Type) object).isDomainType()) { |
| return (Type) object; |
| } |
| } |
| |
| if (raise) { |
| throw Error.error(ErrorCode.X_42501, name); |
| } |
| |
| return null; |
| } |
| |
| public Type getDistinctType(String name, String schemaName, |
| boolean raise) { |
| |
| Schema schema = (Schema) schemaMap.get(schemaName); |
| |
| if (schema != null) { |
| SchemaObject object = schema.typeLookup.getObject(name); |
| |
| if (object != null && ((Type) object).isDomainType()) { |
| return (Type) object; |
| } |
| } |
| |
| if (raise) { |
| throw Error.error(ErrorCode.X_42501, name); |
| } |
| |
| return null; |
| } |
| |
| public SchemaObject getSchemaObject(String name, String schemaName, |
| int type) { |
| |
| SchemaObject object = findSchemaObject(name, schemaName, type); |
| |
| if (object == null) { |
| throw Error.error(SchemaObjectSet.getGetErrorCode(type), name); |
| } |
| |
| return object; |
| } |
| |
| public SchemaObject findSchemaObject(String name, String schemaName, |
| int type) { |
| |
| Schema schema = (Schema) schemaMap.get(schemaName); |
| |
| if (schema == null) { |
| return null; |
| } |
| |
| SchemaObjectSet set = null; |
| HsqlName objectName; |
| Table table; |
| |
| switch (type) { |
| |
| case SchemaObject.SEQUENCE : |
| return schema.sequenceLookup.getObject(name); |
| |
| case SchemaObject.TABLE : |
| case SchemaObject.VIEW : |
| return schema.tableLookup.getObject(name); |
| |
| case SchemaObject.CHARSET : |
| if (name.equals("SQL_IDENTIFIER")) { |
| return SqlInvariants.SQL_IDENTIFIER_CHARSET; |
| } |
| |
| if (name.equals("SQL_TEXT")) { |
| return SqlInvariants.SQL_TEXT; |
| } |
| |
| if (name.equals("LATIN1")) { |
| return SqlInvariants.LATIN1; |
| } |
| |
| if (name.equals("ASCII_GRAPHIC")) { |
| return SqlInvariants.ASCII_GRAPHIC; |
| } |
| |
| return schema.charsetLookup.getObject(name); |
| |
| case SchemaObject.COLLATION : |
| return schema.collationLookup.getObject(name); |
| |
| case SchemaObject.PROCEDURE : |
| return schema.procedureLookup.getObject(name); |
| |
| case SchemaObject.FUNCTION : |
| return schema.functionLookup.getObject(name); |
| |
| case SchemaObject.ROUTINE : { |
| SchemaObject object = schema.procedureLookup.getObject(name); |
| |
| if (object == null) { |
| object = schema.functionLookup.getObject(name); |
| } |
| |
| return object; |
| } |
| case SchemaObject.SPECIFIC_ROUTINE : |
| return schema.specificRoutineLookup.getObject(name); |
| |
| case SchemaObject.DOMAIN : |
| case SchemaObject.TYPE : |
| return schema.typeLookup.getObject(name); |
| |
| case SchemaObject.INDEX : |
| set = schema.indexLookup; |
| objectName = set.getName(name); |
| |
| if (objectName == null) { |
| return null; |
| } |
| |
| table = (Table) schema.tableList.get(objectName.parent.name); |
| |
| return table.getIndex(name); |
| |
| case SchemaObject.CONSTRAINT : |
| set = schema.constraintLookup; |
| objectName = set.getName(name); |
| |
| if (objectName == null) { |
| return null; |
| } |
| |
| table = (Table) schema.tableList.get(objectName.parent.name); |
| |
| if (table == null) { |
| return null; |
| } |
| |
| return table.getConstraint(name); |
| |
| case SchemaObject.TRIGGER : |
| set = schema.indexLookup; |
| objectName = set.getName(name); |
| |
| if (objectName == null) { |
| return null; |
| } |
| |
| table = (Table) schema.tableList.get(objectName.parent.name); |
| |
| return table.getTrigger(name); |
| |
| default : |
| throw Error.runtimeError(ErrorCode.U_S0500, "SchemaManager"); |
| } |
| } |
| |
| // INDEX management |
| |
| /** |
| * Returns the table that has an index with the given name and schema. |
| */ |
| Table findUserTableForIndex(Session session, String name, |
| String schemaName) { |
| |
| Schema schema = (Schema) schemaMap.get(schemaName); |
| HsqlName indexName = schema.indexLookup.getName(name); |
| |
| if (indexName == null) { |
| return null; |
| } |
| |
| return findUserTable(session, indexName.parent.name, schemaName); |
| } |
| |
| /** |
| * Drops the index with the specified name. |
| */ |
| void dropIndex(Session session, HsqlName name) { |
| |
| Table t = getTable(session, name.parent.name, name.parent.schema.name); |
| TableWorks tw = new TableWorks(session, t); |
| |
| tw.dropIndex(name.name); |
| } |
| |
| /** |
| * Drops the index with the specified name. |
| */ |
| void dropConstraint(Session session, HsqlName name, boolean cascade) { |
| |
| Table t = getTable(session, name.parent.name, name.parent.schema.name); |
| TableWorks tw = new TableWorks(session, t); |
| |
| tw.dropConstraint(name.name, cascade); |
| } |
| |
| void removeDependentObjects(HsqlName name) { |
| |
| Schema schema = (Schema) schemaMap.get(name.schema.name); |
| |
| schema.indexLookup.removeParent(name); |
| schema.constraintLookup.removeParent(name); |
| schema.triggerLookup.removeParent(name); |
| } |
| |
| /** |
| * Removes any foreign key Constraint objects (exported keys) held by any |
| * tables referenced by the specified table. <p> |
| * |
| * This method is called as the last step of a successful call to |
| * dropTable() in order to ensure that the dropped Table ceases to be |
| * referenced when enforcing referential integrity. |
| * |
| * @param toDrop The table to which other tables may be holding keys. |
| * This is a table that is in the process of being dropped. |
| */ |
| void removeExportedKeys(Table toDrop) { |
| |
| // toDrop.schema may be null because it is not registerd |
| Schema schema = (Schema) schemaMap.get(toDrop.getSchemaName().name); |
| |
| for (int i = 0; i < schema.tableList.size(); i++) { |
| Table table = (Table) schema.tableList.get(i); |
| Constraint[] constraints = table.getConstraints(); |
| |
| for (int j = constraints.length - 1; j >= 0; j--) { |
| Table refTable = constraints[j].getRef(); |
| |
| if (toDrop == refTable) { |
| table.removeConstraint(j); |
| } |
| } |
| } |
| } |
| |
| public Iterator databaseObjectIterator(String schemaName, int type) { |
| |
| Schema schema = (Schema) schemaMap.get(schemaName); |
| |
| return schema.schemaObjectIterator(type); |
| } |
| |
| public Iterator databaseObjectIterator(int type) { |
| |
| Iterator it = schemaMap.values().iterator(); |
| Iterator objects = new WrapperIterator(); |
| |
| while (it.hasNext()) { |
| Schema temp = (Schema) it.next(); |
| |
| objects = new WrapperIterator(objects, |
| temp.schemaObjectIterator(type)); |
| } |
| |
| return objects; |
| } |
| |
| // references |
| private void addReferences(SchemaObject object) { |
| |
| OrderedHashSet set = object.getReferences(); |
| |
| if (set == null) { |
| return; |
| } |
| |
| for (int i = 0; i < set.size(); i++) { |
| HsqlName referenced = (HsqlName) set.get(i); |
| HsqlName name = object.getName(); |
| |
| if (object instanceof Routine) { |
| name = ((Routine) object).getSpecificName(); |
| } |
| |
| referenceMap.put(referenced, name); |
| } |
| } |
| |
| private void removeReferencedObject(HsqlName referenced) { |
| referenceMap.remove(referenced); |
| } |
| |
| private void removeReferencingObject(SchemaObject object) { |
| |
| OrderedHashSet set = object.getReferences(); |
| |
| if (set == null) { |
| return; |
| } |
| |
| for (int i = 0; i < set.size(); i++) { |
| HsqlName referenced = (HsqlName) set.get(i); |
| HsqlName name = object.getName(); |
| |
| if (object instanceof Routine) { |
| name = ((Routine) object).getSpecificName(); |
| } |
| |
| referenceMap.remove(referenced, name); |
| |
| if (name.parent != null) { |
| referenceMap.remove(referenced, name.parent); |
| } |
| } |
| } |
| |
| OrderedHashSet getReferencingObjectNames(HsqlName object) { |
| |
| OrderedHashSet set = new OrderedHashSet(); |
| Iterator it = referenceMap.get(object); |
| |
| while (it.hasNext()) { |
| HsqlName name = (HsqlName) it.next(); |
| |
| set.add(name); |
| } |
| |
| return set; |
| } |
| |
| public OrderedHashSet getReferencingObjectNames(HsqlName table, |
| HsqlName column) { |
| |
| OrderedHashSet set = new OrderedHashSet(); |
| Iterator it = referenceMap.get(table); |
| |
| while (it.hasNext()) { |
| HsqlName name = (HsqlName) it.next(); |
| SchemaObject object = getSchemaObject(name); |
| OrderedHashSet references = object.getReferences(); |
| |
| if (references.contains(column)) { |
| set.add(name); |
| } |
| } |
| |
| return set; |
| } |
| |
| private boolean isReferenced(HsqlName object) { |
| return referenceMap.containsKey(object); |
| } |
| |
| // |
| public void getCascadingReferencingObjectNames(HsqlName object, |
| OrderedHashSet set) { |
| |
| OrderedHashSet newSet = new OrderedHashSet(); |
| Iterator it = referenceMap.get(object); |
| |
| while (it.hasNext()) { |
| HsqlName name = (HsqlName) it.next(); |
| boolean added = set.add(name); |
| |
| if (added) { |
| newSet.add(name); |
| } |
| } |
| |
| for (int i = 0; i < newSet.size(); i++) { |
| HsqlName name = (HsqlName) newSet.get(i); |
| |
| getCascadingReferencingObjectNames(name, set); |
| } |
| } |
| |
| // |
| private void getCascadingSchemaReferences(HsqlName schema, |
| OrderedHashSet set) { |
| |
| Iterator mainIterator = referenceMap.keySet().iterator(); |
| |
| while (mainIterator.hasNext()) { |
| HsqlName name = (HsqlName) mainIterator.next(); |
| |
| if (name.schema != schema) { |
| continue; |
| } |
| |
| getCascadingReferencingObjectNames(name, set); |
| } |
| |
| for (int i = 0; i < set.size(); i++) { |
| HsqlName name = (HsqlName) set.get(i); |
| |
| if (name.schema == schema) { |
| set.remove(i); |
| |
| i--; |
| } |
| } |
| } |
| |
| // |
| public HsqlName getSchemaObjectName(HsqlName schemaName, String name, |
| int type, boolean raise) { |
| |
| Schema schema = (Schema) schemaMap.get(schemaName.name); |
| SchemaObjectSet set = null; |
| |
| if (schema == null) { |
| if (raise) { |
| throw Error.error(SchemaObjectSet.getGetErrorCode(type)); |
| } else { |
| return null; |
| } |
| } |
| |
| if (type == SchemaObject.ROUTINE) { |
| set = schema.functionLookup; |
| |
| SchemaObject object = schema.functionLookup.getObject(name); |
| |
| if (object == null) { |
| set = schema.procedureLookup; |
| object = schema.procedureLookup.getObject(name); |
| } |
| } else { |
| set = getSchemaObjectSet(schema, type); |
| } |
| |
| if (raise) { |
| set.checkExists(name); |
| } |
| |
| return set.getName(name); |
| } |
| |
| public SchemaObject getSchemaObject(HsqlName name) { |
| |
| Schema schema = (Schema) schemaMap.get(name.schema.name); |
| |
| if (schema == null) { |
| return null; |
| } |
| |
| switch (name.type) { |
| |
| case SchemaObject.SEQUENCE : |
| return (SchemaObject) schema.sequenceList.get(name.name); |
| |
| case SchemaObject.TABLE : |
| case SchemaObject.VIEW : |
| return (SchemaObject) schema.tableList.get(name.name); |
| |
| case SchemaObject.CHARSET : |
| return schema.charsetLookup.getObject(name.name); |
| |
| case SchemaObject.COLLATION : |
| return schema.collationLookup.getObject(name.name); |
| |
| case SchemaObject.PROCEDURE : |
| return schema.procedureLookup.getObject(name.name); |
| |
| case SchemaObject.FUNCTION : |
| return schema.functionLookup.getObject(name.name); |
| |
| case RoutineSchema.SPECIFIC_ROUTINE : |
| return schema.specificRoutineLookup.getObject(name.name); |
| |
| case RoutineSchema.ROUTINE : |
| SchemaObject object = |
| schema.functionLookup.getObject(name.name); |
| |
| if (object == null) { |
| object = schema.procedureLookup.getObject(name.name); |
| } |
| |
| return object; |
| |
| case SchemaObject.DOMAIN : |
| case SchemaObject.TYPE : |
| return schema.typeLookup.getObject(name.name); |
| |
| case SchemaObject.TRIGGER : { |
| name = schema.triggerLookup.getName(name.name); |
| |
| if (name == null) { |
| return null; |
| } |
| |
| HsqlName tableName = name.parent; |
| Table table = (Table) schema.tableList.get(tableName.name); |
| |
| return table.getTrigger(name.name); |
| } |
| case SchemaObject.CONSTRAINT : { |
| name = schema.constraintLookup.getName(name.name); |
| |
| if (name == null) { |
| return null; |
| } |
| |
| HsqlName tableName = name.parent; |
| Table table = (Table) schema.tableList.get(tableName.name); |
| |
| return table.getConstraint(name.name); |
| } |
| case SchemaObject.ASSERTION : |
| return null; |
| |
| case SchemaObject.INDEX : |
| name = schema.indexLookup.getName(name.name); |
| |
| if (name == null) { |
| return null; |
| } |
| |
| HsqlName tableName = name.parent; |
| Table table = (Table) schema.tableList.get(tableName.name); |
| |
| return table.getIndex(name.name); |
| } |
| |
| return null; |
| } |
| |
| public void checkColumnIsReferenced(HsqlName tableName, HsqlName name) { |
| |
| OrderedHashSet set = getReferencingObjectNames(tableName, name); |
| |
| if (!set.isEmpty()) { |
| HsqlName objectName = (HsqlName) set.get(0); |
| |
| throw Error.error(ErrorCode.X_42502, |
| objectName.getSchemaQualifiedStatementName()); |
| } |
| } |
| |
| public void checkObjectIsReferenced(HsqlName name) { |
| |
| OrderedHashSet set = getReferencingObjectNames(name); |
| HsqlName refName = null; |
| |
| for (int i = 0; i < set.size(); i++) { |
| refName = (HsqlName) set.get(i); |
| |
| // except columns of same table |
| if (refName.parent != name) { |
| break; |
| } |
| |
| refName = null; |
| } |
| |
| if (refName == null) { |
| return; |
| } |
| |
| throw Error.error(ErrorCode.X_42502, |
| refName.getSchemaQualifiedStatementName()); |
| } |
| |
| public void checkSchemaNameCanChange(HsqlName name) { |
| |
| Iterator it = referenceMap.values().iterator(); |
| HsqlName refName = null; |
| |
| mainLoop: |
| while (it.hasNext()) { |
| refName = (HsqlName) it.next(); |
| |
| switch (refName.type) { |
| |
| case SchemaObject.VIEW : |
| case SchemaObject.ROUTINE : |
| case SchemaObject.FUNCTION : |
| case SchemaObject.PROCEDURE : |
| case SchemaObject.TRIGGER : |
| case SchemaObject.SPECIFIC_ROUTINE : |
| if (refName.schema == name) { |
| break mainLoop; |
| } |
| break; |
| |
| default : |
| break; |
| } |
| |
| refName = null; |
| } |
| |
| if (refName == null) { |
| return; |
| } |
| |
| throw Error.error(ErrorCode.X_42502, |
| refName.getSchemaQualifiedStatementName()); |
| } |
| |
| public void addSchemaObject(SchemaObject object) { |
| |
| HsqlName name = object.getName(); |
| Schema schema = (Schema) schemaMap.get(name.schema.name); |
| SchemaObjectSet set = getSchemaObjectSet(schema, name.type); |
| |
| switch (name.type) { |
| |
| case SchemaObject.PROCEDURE : |
| case SchemaObject.FUNCTION : { |
| RoutineSchema routine = |
| (RoutineSchema) set.getObject(name.name); |
| |
| if (routine == null) { |
| routine = new RoutineSchema(name.type, name); |
| |
| routine.addSpecificRoutine(database, (Routine) object); |
| set.checkAdd(name); |
| |
| SchemaObjectSet specificSet = getSchemaObjectSet(schema, |
| SchemaObject.SPECIFIC_ROUTINE); |
| |
| specificSet.checkAdd(((Routine) object).getSpecificName()); |
| set.add(routine); |
| specificSet.add(object); |
| } else { |
| SchemaObjectSet specificSet = getSchemaObjectSet(schema, |
| SchemaObject.SPECIFIC_ROUTINE); |
| HsqlName specificName = |
| ((Routine) object).getSpecificName(); |
| |
| if (specificName != null) { |
| specificSet.checkAdd(specificName); |
| } |
| |
| routine.addSpecificRoutine(database, (Routine) object); |
| specificSet.add(object); |
| } |
| |
| addReferences(object); |
| |
| return; |
| } |
| case SchemaObject.TABLE : { |
| OrderedHashSet refs = object.getReferences(); |
| |
| for (int i = 0; i < refs.size(); i++) { |
| HsqlName ref = (HsqlName) refs.get(i); |
| |
| if (ref.type == SchemaObject.COLUMN) { |
| int index = ((Table) object).findColumn(ref.name); |
| ColumnSchema column = |
| ((Table) object).getColumn(index); |
| |
| addSchemaObject(column); |
| } |
| } |
| |
| break; |
| } |
| case SchemaObject.COLUMN : { |
| if (object.getReferences().isEmpty()) { |
| return; |
| } |
| |
| break; |
| } |
| } |
| |
| if (set != null) { |
| set.add(object); |
| } |
| |
| addReferences(object); |
| } |
| |
| public void removeSchemaObject(HsqlName name, boolean cascade) { |
| |
| OrderedHashSet objectSet = new OrderedHashSet(); |
| |
| switch (name.type) { |
| |
| case SchemaObject.ROUTINE : |
| case SchemaObject.PROCEDURE : |
| case SchemaObject.FUNCTION : { |
| RoutineSchema routine = (RoutineSchema) getSchemaObject(name); |
| |
| if (routine != null) { |
| Routine[] specifics = routine.getSpecificRoutines(); |
| |
| for (int i = 0; i < specifics.length; i++) { |
| getCascadingReferencingObjectNames( |
| specifics[i].getSpecificName(), objectSet); |
| } |
| } |
| } |
| break; |
| |
| case SchemaObject.SEQUENCE : |
| case SchemaObject.TABLE : |
| case SchemaObject.VIEW : |
| case SchemaObject.TYPE : |
| case SchemaObject.CHARSET : |
| case SchemaObject.COLLATION : |
| case SchemaObject.SPECIFIC_ROUTINE : |
| getCascadingReferencingObjectNames(name, objectSet); |
| break; |
| |
| case SchemaObject.DOMAIN : |
| OrderedHashSet set = getReferencingObjectNames(name); |
| Iterator it = set.iterator(); |
| |
| while (it.hasNext()) { |
| HsqlName ref = (HsqlName) it.next(); |
| |
| if (ref.type == SchemaObject.COLUMN) { |
| it.remove(); |
| } |
| } |
| |
| if (!set.isEmpty()) { |
| HsqlName objectName = (HsqlName) set.get(0); |
| |
| throw Error.error( |
| ErrorCode.X_42502, |
| objectName.getSchemaQualifiedStatementName()); |
| } |
| break; |
| } |
| |
| if (objectSet.isEmpty()) { |
| removeSchemaObject(name); |
| |
| return; |
| } |
| |
| if (!cascade) { |
| HsqlName objectName = (HsqlName) objectSet.get(0); |
| |
| throw Error.error(ErrorCode.X_42502, |
| objectName.getSchemaQualifiedStatementName()); |
| } |
| |
| objectSet.add(name); |
| removeSchemaObjects(objectSet); |
| } |
| |
| public void removeSchemaObjects(OrderedHashSet set) { |
| |
| for (int i = 0; i < set.size(); i++) { |
| HsqlName name = (HsqlName) set.get(i); |
| |
| removeSchemaObject(name); |
| } |
| } |
| |
| public void removeSchemaObject(HsqlName name) { |
| |
| Schema schema = (Schema) schemaMap.get(name.schema.name); |
| SchemaObject object = null; |
| SchemaObjectSet set = null; |
| |
| switch (name.type) { |
| |
| case SchemaObject.SEQUENCE : |
| set = schema.sequenceLookup; |
| object = set.getObject(name.name); |
| break; |
| |
| case SchemaObject.TABLE : |
| case SchemaObject.VIEW : { |
| set = schema.tableLookup; |
| object = set.getObject(name.name); |
| |
| break; |
| } |
| case SchemaObject.COLUMN : { |
| Table table = (Table) getSchemaObject(name.parent); |
| |
| if (table != null) { |
| object = table.getColumn(table.getColumnIndex(name.name)); |
| } |
| |
| break; |
| } |
| case SchemaObject.CHARSET : |
| set = schema.charsetLookup; |
| object = set.getObject(name.name); |
| break; |
| |
| case SchemaObject.COLLATION : |
| set = schema.collationLookup; |
| object = set.getObject(name.name); |
| break; |
| |
| case SchemaObject.PROCEDURE : { |
| set = schema.procedureLookup; |
| |
| RoutineSchema routine = |
| (RoutineSchema) set.getObject(name.name); |
| |
| object = routine; |
| |
| Routine[] specifics = routine.getSpecificRoutines(); |
| |
| for (int i = 0; i < specifics.length; i++) { |
| removeSchemaObject(specifics[i].getSpecificName()); |
| } |
| |
| break; |
| } |
| case SchemaObject.FUNCTION : { |
| set = schema.functionLookup; |
| |
| RoutineSchema routine = |
| (RoutineSchema) set.getObject(name.name); |
| |
| object = routine; |
| |
| Routine[] specifics = routine.getSpecificRoutines(); |
| |
| for (int i = 0; i < specifics.length; i++) { |
| removeSchemaObject(specifics[i].getSpecificName()); |
| } |
| |
| break; |
| } |
| case SchemaObject.SPECIFIC_ROUTINE : { |
| set = schema.specificRoutineLookup; |
| |
| Routine routine = (Routine) set.getObject(name.name); |
| |
| object = routine; |
| |
| routine.routineSchema.removeSpecificRoutine(routine); |
| |
| if (routine.routineSchema.getSpecificRoutines().length == 0) { |
| removeSchemaObject(routine.getName()); |
| } |
| |
| break; |
| } |
| case SchemaObject.DOMAIN : |
| case SchemaObject.TYPE : |
| set = schema.typeLookup; |
| object = set.getObject(name.name); |
| break; |
| |
| case SchemaObject.INDEX : |
| set = schema.indexLookup; |
| break; |
| |
| case SchemaObject.CONSTRAINT : { |
| set = schema.constraintLookup; |
| |
| if (name.parent.type == SchemaObject.TABLE) { |
| Table table = |
| (Table) schema.tableList.get(name.parent.name); |
| |
| object = table.getConstraint(name.name); |
| |
| table.removeConstraint(name.name); |
| } else if (name.parent.type == SchemaObject.DOMAIN) { |
| Type type = |
| (Type) schema.typeLookup.getObject(name.parent.name); |
| |
| object = type.userTypeModifier.getConstraint(name.name); |
| |
| type.userTypeModifier.removeConstraint(name.name); |
| } |
| |
| break; |
| } |
| case SchemaObject.TRIGGER : { |
| set = schema.triggerLookup; |
| |
| Table table = (Table) schema.tableList.get(name.parent.name); |
| |
| object = table.getTrigger(name.name); |
| |
| if (object != null) { |
| table.removeTrigger((TriggerDef) object); |
| } |
| |
| break; |
| } |
| default : |
| throw Error.runtimeError(ErrorCode.U_S0500, "SchemaManager"); |
| } |
| |
| if (object != null) { |
| database.getGranteeManager().removeDbObject(name); |
| removeReferencingObject(object); |
| } |
| |
| if (set != null) { |
| set.remove(name.name); |
| } |
| |
| removeReferencedObject(name); |
| } |
| |
| public void renameSchemaObject(HsqlName name, HsqlName newName) { |
| |
| if (name.schema != newName.schema) { |
| throw Error.error(ErrorCode.X_42505, newName.schema.name); |
| } |
| |
| checkObjectIsReferenced(name); |
| |
| Schema schema = (Schema) schemaMap.get(name.schema.name); |
| SchemaObjectSet set = getSchemaObjectSet(schema, name.type); |
| |
| set.rename(name, newName); |
| } |
| |
| public String[] getSQLArray() { |
| |
| OrderedHashSet resolved = new OrderedHashSet(); |
| OrderedHashSet unresolved = new OrderedHashSet(); |
| HsqlArrayList list = new HsqlArrayList(); |
| Iterator schemas = schemaMap.values().iterator(); |
| |
| schemas = schemaMap.values().iterator(); |
| |
| while (schemas.hasNext()) { |
| Schema schema = (Schema) schemas.next(); |
| |
| if (SqlInvariants.isSystemSchemaName(schema.getName().name)) { |
| continue; |
| } |
| |
| if (SqlInvariants.isLobsSchemaName(schema.getName().name)) { |
| continue; |
| } |
| |
| list.add(schema.getSQL()); |
| schema.addSimpleObjects(unresolved); |
| } |
| |
| while (true) { |
| Iterator it = unresolved.iterator(); |
| |
| if (!it.hasNext()) { |
| break; |
| } |
| |
| OrderedHashSet newResolved = new OrderedHashSet(); |
| |
| SchemaObjectSet.addAllSQL(resolved, unresolved, list, it, |
| newResolved); |
| unresolved.removeAll(newResolved); |
| |
| if (newResolved.size() == 0) { |
| break; |
| } |
| } |
| |
| schemas = schemaMap.values().iterator(); |
| |
| while (schemas.hasNext()) { |
| Schema schema = (Schema) schemas.next(); |
| |
| if (SqlInvariants.isLobsSchemaName(schema.getName().name)) { |
| continue; |
| } |
| |
| if (SqlInvariants.isSystemSchemaName(schema.getName().name)) { |
| continue; |
| } |
| |
| list.addAll(schema.getSQLArray(resolved, unresolved)); |
| } |
| |
| while (true) { |
| Iterator it = unresolved.iterator(); |
| |
| if (!it.hasNext()) { |
| break; |
| } |
| |
| OrderedHashSet newResolved = new OrderedHashSet(); |
| |
| SchemaObjectSet.addAllSQL(resolved, unresolved, list, it, |
| newResolved); |
| unresolved.removeAll(newResolved); |
| |
| if (newResolved.size() == 0) { |
| break; |
| } |
| } |
| |
| schemas = schemaMap.values().iterator(); |
| |
| while (schemas.hasNext()) { |
| Schema schema = (Schema) schemas.next(); |
| |
| if (SqlInvariants.isLobsSchemaName(schema.getName().name)) { |
| continue; |
| } |
| |
| if (SqlInvariants.isSystemSchemaName(schema.getName().name)) { |
| continue; |
| } |
| |
| String[] t = schema.getTriggerSQL(); |
| |
| if (t.length > 0) { |
| list.add(Schema.getSetSchemaSQL(schema.getName())); |
| list.addAll(t); |
| } |
| |
| list.addAll(schema.getSequenceRestartSQL()); |
| } |
| |
| schemas = schemaMap.values().iterator(); |
| |
| while (schemas.hasNext()) { |
| Schema schema = (Schema) schemas.next(); |
| |
| list.addAll(schema.getSequenceRestartSQL()); |
| } |
| |
| if (defaultSchemaHsqlName != null) { |
| StringBuffer sb = new StringBuffer(); |
| |
| sb.append(Tokens.T_SET).append(' ').append(Tokens.T_DATABASE); |
| sb.append(' ').append(Tokens.T_DEFAULT).append(' '); |
| sb.append(Tokens.T_INITIAL).append(' ').append(Tokens.T_SCHEMA); |
| sb.append(' ').append(defaultSchemaHsqlName.statementName); |
| list.add(sb.toString()); |
| } |
| |
| String[] array = new String[list.size()]; |
| |
| list.toArray(array); |
| |
| return array; |
| } |
| |
| public String[] getTablePropsSQL(boolean withHeader) { |
| |
| HsqlArrayList tableList = getAllTables(); |
| HsqlArrayList list = new HsqlArrayList(); |
| |
| for (int i = 0; i < tableList.size(); i++) { |
| Table t = (Table) tableList.get(i); |
| |
| if (t.isText()) { |
| String[] ddl = t.getSQLForTextSource(withHeader); |
| |
| list.addAll(ddl); |
| } else { |
| String ddl = t.getSQLForReadOnly(); |
| |
| if (ddl != null) { |
| list.add(ddl); |
| } |
| } |
| } |
| |
| String[] array = new String[list.size()]; |
| |
| list.toArray(array); |
| |
| return array; |
| } |
| |
| public String[] getIndexRootsSQL() { |
| |
| Session sysSession = database.sessionManager.getSysSession(); |
| int[][] rootsArray = getIndexRoots(sysSession); |
| HsqlArrayList tableList = getAllTables(); |
| HsqlArrayList list = new HsqlArrayList(); |
| |
| for (int i = 0; i < rootsArray.length; i++) { |
| Table t = (Table) tableList.get(i); |
| |
| if (rootsArray[i] != null && rootsArray[i].length > 0 |
| && rootsArray[i][0] != -1) { |
| String ddl = |
| ((Table) tableList.get(i)).getIndexRootsSQL(rootsArray[i]); |
| |
| list.add(ddl); |
| } |
| } |
| |
| String[] array = new String[list.size()]; |
| |
| list.toArray(array); |
| |
| return array; |
| } |
| |
| public String[] getCommentsArray() { |
| |
| HsqlArrayList tableList = getAllTables(); |
| HsqlArrayList list = new HsqlArrayList(); |
| StringBuffer sb = new StringBuffer(); |
| |
| for (int i = 0; i < tableList.size(); i++) { |
| Table table = (Table) tableList.get(i); |
| |
| if (table.getTableType() == Table.SYSTEM_TABLE) { |
| continue; |
| } |
| |
| int colCount = table.getColumnCount(); |
| |
| for (int j = 0; j < colCount; j++) { |
| ColumnSchema column = table.getColumn(j); |
| |
| if (column.getName().comment == null) { |
| continue; |
| } |
| |
| sb.setLength(0); |
| sb.append(Tokens.T_COMMENT).append(' ').append(Tokens.T_ON); |
| sb.append(' ').append(Tokens.T_COLUMN).append(' '); |
| sb.append(table.getName().getSchemaQualifiedStatementName()); |
| sb.append('.').append(column.getName().statementName); |
| sb.append(' ').append(Tokens.T_IS).append(' '); |
| sb.append( |
| StringConverter.toQuotedString( |
| column.getName().comment, '\'', true)); |
| list.add(sb.toString()); |
| } |
| |
| if (table.getName().comment == null) { |
| continue; |
| } |
| |
| sb.setLength(0); |
| sb.append(Tokens.T_COMMENT).append(' ').append(Tokens.T_ON); |
| sb.append(' ').append(Tokens.T_TABLE).append(' '); |
| sb.append(table.getName().getSchemaQualifiedStatementName()); |
| sb.append(' ').append(Tokens.T_IS).append(' '); |
| sb.append(StringConverter.toQuotedString(table.getName().comment, |
| '\'', true)); |
| list.add(sb.toString()); |
| } |
| |
| Iterator it = databaseObjectIterator(SchemaObject.ROUTINE); |
| |
| while (it.hasNext()) { |
| SchemaObject object = (SchemaObject) it.next(); |
| |
| if (object.getName().comment == null) { |
| continue; |
| } |
| |
| sb.setLength(0); |
| sb.append(Tokens.T_COMMENT).append(' ').append(Tokens.T_ON); |
| sb.append(' ').append(Tokens.T_ROUTINE).append(' '); |
| sb.append(object.getName().getSchemaQualifiedStatementName()); |
| sb.append(' ').append(Tokens.T_IS).append(' '); |
| sb.append(StringConverter.toQuotedString(object.getName().comment, |
| '\'', true)); |
| list.add(sb.toString()); |
| } |
| |
| String[] array = new String[list.size()]; |
| |
| list.toArray(array); |
| |
| return array; |
| } |
| |
| int[][] tempIndexRoots; |
| |
| public void setTempIndexRoots(int[][] roots) { |
| tempIndexRoots = roots; |
| } |
| |
| public int[][] getIndexRoots(Session session) { |
| |
| if (tempIndexRoots != null) { |
| int[][] roots = tempIndexRoots; |
| |
| tempIndexRoots = null; |
| |
| return roots; |
| } |
| |
| HsqlArrayList allTables = getAllTables(); |
| HsqlArrayList list = new HsqlArrayList(); |
| |
| for (int i = 0, size = allTables.size(); i < size; i++) { |
| Table t = (Table) allTables.get(i); |
| |
| if (t.getTableType() == TableBase.CACHED_TABLE) { |
| int[] roots = t.getIndexRootsArray(); |
| |
| list.add(roots); |
| } else { |
| list.add(null); |
| } |
| } |
| |
| int[][] array = new int[list.size()][]; |
| |
| list.toArray(array); |
| |
| return array; |
| } |
| |
| /** |
| * called after the completion of defrag |
| */ |
| public void setIndexRoots(int[][] roots) { |
| |
| HsqlArrayList allTables = database.schemaManager.getAllTables(); |
| |
| for (int i = 0, size = allTables.size(); i < size; i++) { |
| Table t = (Table) allTables.get(i); |
| |
| if (t.getTableType() == TableBase.CACHED_TABLE) { |
| int[] rootsArray = roots[i]; |
| |
| if (roots != null) { |
| t.setIndexRoots(rootsArray); |
| } |
| } |
| } |
| } |
| |
| public void setDefaultTableType(int type) { |
| defaultTableType = type; |
| } |
| |
| public int getDefaultTableType() { |
| return defaultTableType; |
| } |
| } |
