boolean forCreateTable;
TableDescriptor td;
UUID toid;
ColumnDescriptor columnDescriptor;
int[] baseColumnPositions;
IndexRowGenerator indexRowGenerator = null;
ExecRow[] baseRows;
ExecIndexRow[] indexRows;
ExecRow[] compactBaseRows;
GroupFetchScanController scan;
RowLocationRetRowSource rowSource;
long sortId;
int maxBaseColumnPosition = -1;
LanguageConnectionContext lcc = activation.getLanguageConnectionContext();
DataDictionary dd = lcc.getDataDictionary();
DependencyManager dm = dd.getDependencyManager();
TransactionController tc = lcc.getTransactionExecute();
/* Remember whether or not we are doing a create table */
forCreateTable = activation.getForCreateTable();
/*
** Inform the data dictionary that we are about to write to it.
** There are several calls to data dictionary "get" methods here
** that might be done in "read" mode in the data dictionary, but
** it seemed safer to do this whole operation in "write" mode.
**
** We tell the data dictionary we're done writing at the end of
** the transaction.
*/
dd.startWriting(lcc);
/*
** If the schema descriptor is null, then
** we must have just read ourselves in.
** So we will get the corresponding schema
** descriptor from the data dictionary.
*/
SchemaDescriptor sd = dd.getSchemaDescriptor(schemaName, tc, true) ;
/* Get the table descriptor. */
/* See if we can get the TableDescriptor
* from the Activation. (Will be there
* for backing indexes.)
*/
td = activation.getDDLTableDescriptor();
if (td == null)
{
/* tableId will be non-null if adding an index to
* an existing table (as opposed to creating a
* table with a constraint with a backing index).
*/
if (tableId != null)
{
td = dd.getTableDescriptor(tableId);
}
else
{
td = dd.getTableDescriptor(tableName, sd);
}
}
if (td == null)
{
throw StandardException.newException(SQLState.LANG_CREATE_INDEX_NO_TABLE,
indexName, tableName);
}
if (td.getTableType() == TableDescriptor.SYSTEM_TABLE_TYPE)
{
throw StandardException.newException(SQLState.LANG_CREATE_SYSTEM_INDEX_ATTEMPTED,
indexName, tableName);
}
/* Get a shared table lock on the table. We need to lock table before
* invalidate dependents, otherwise, we may interfere with the
* compilation/re-compilation of DML/DDL. See beetle 4325 and $WS/
* docs/language/SolutionsToConcurrencyIssues.txt (point f).
*/
lockTableForDDL(tc, td.getHeapConglomerateId(), false);
// invalidate any prepared statements that
// depended on this table (including this one)
if (! forCreateTable)
{
dm.invalidateFor(td, DependencyManager.CREATE_INDEX, lcc);
}
// Translate the base column names to column positions
baseColumnPositions = new int[columnNames.length];
for (int i = 0; i < columnNames.length; i++)
{
// Look up the column in the data dictionary
columnDescriptor = td.getColumnDescriptor(columnNames[i]);
if (columnDescriptor == null)
{
throw StandardException.newException(SQLState.LANG_COLUMN_NOT_FOUND_IN_TABLE,
columnNames[i],
tableName);
}
TypeId typeId = columnDescriptor.getType().getTypeId();
// Don't allow a column to be created on a non-orderable type
ClassFactory cf = lcc.getLanguageConnectionFactory().getClassFactory();
boolean isIndexable = typeId.orderable(cf);
if (isIndexable && typeId.userType()) {
String userClass = typeId.getCorrespondingJavaTypeName();
// Don't allow indexes to be created on classes that
// are loaded from the database. This is because recovery
// won't be able to see the class and it will need it to
// run the compare method.
try {
if (cf.isApplicationClass(cf.loadApplicationClass(userClass)))
isIndexable = false;
} catch (ClassNotFoundException cnfe) {
// shouldn't happen as we just check the class is orderable
isIndexable = false;
}
}
if (!isIndexable) {
throw StandardException.newException(SQLState.LANG_COLUMN_NOT_ORDERABLE_DURING_EXECUTION,
typeId.getSQLTypeName());
}
// Remember the position in the base table of each column
baseColumnPositions[i] = columnDescriptor.getPosition();
if (maxBaseColumnPosition < baseColumnPositions[i])
maxBaseColumnPosition = baseColumnPositions[i];
}
// check if we have similar indices already for this table
ConglomerateDescriptor[] congDescs = td.getConglomerateDescriptors();
boolean duplicate = false;
long conglomId = 0;
for (int i = 0; i < congDescs.length; i++)
{
ConglomerateDescriptor cd = congDescs[i];
if ( ! cd.isIndex())
continue;
IndexRowGenerator irg = cd.getIndexDescriptor();
int[] bcps = irg.baseColumnPositions();
boolean[] ia = irg.isAscending();
int j = 0;
/* For an index to be considered a duplicate of already existing index, the
* following conditions have to be satisfied:
* 1. the set of columns (both key and include columns) and their
* order in the index is the same as that of an existing index AND
* 2. the ordering attributes are the same AND
* 3. both the previously existing index and the one being created
* are non-unique OR the previously existing index is unique
*/
if ((bcps.length == baseColumnPositions.length) &&
(irg.isUnique() || !unique) &&
indexType.equals(irg.indexType()))
{
for (; j < bcps.length; j++)
{
if ((bcps[j] != baseColumnPositions[j]) || (ia[j] != isAscending[j]))
break;
}
}
if (j == baseColumnPositions.length) // duplicate
{
/*
* Don't allow users to create a duplicate index. Allow if being done internally
* for a constraint
*/
if (!isConstraint)
{
activation.addWarning(
StandardException.newWarning(
SQLState.LANG_INDEX_DUPLICATE,
cd.getConglomerateName()));
return;
}
//Duplicate indexes share the physical conglomerate underneath
conglomId = cd.getConglomerateNumber();
indexRowGenerator = cd.getIndexDescriptor();
//DERBY-655 and DERBY-1343
//Duplicate indexes will have unqiue logical conglomerate UUIDs.
conglomerateUUID = dd.getUUIDFactory().createUUID();
duplicate = true;
break;
}
}
/* If this index already has an essentially same one, we share the
* conglomerate with the old one, and just simply add a descriptor
* entry into SYSCONGLOMERATES.
*/
DataDescriptorGenerator ddg = dd.getDataDescriptorGenerator();
if (duplicate)
{
ConglomerateDescriptor cgd =
ddg.newConglomerateDescriptor(conglomId, indexName, true,
indexRowGenerator, isConstraint,
conglomerateUUID, td.getUUID(), sd.getUUID() );
dd.addDescriptor(cgd, sd, DataDictionary.SYSCONGLOMERATES_CATALOG_NUM, false, tc);
// add newly added conglomerate to the list of conglomerate
// descriptors in the td.
ConglomerateDescriptorList cdl =
td.getConglomerateDescriptorList();
cdl.add(cgd);
// can't just return yet, need to get member "indexTemplateRow"
// because create constraint may use it
}
// Describe the properties of the index to the store using Properties
// RESOLVE: The following properties assume a BTREE index.
Properties indexProperties;
if (properties != null)
{
indexProperties = properties;
}
else
{
indexProperties = new Properties();
}
// Tell it the conglomerate id of the base table
indexProperties.put("baseConglomerateId",
Long.toString(td.getHeapConglomerateId()));
// All indexes are unique because they contain the RowLocation.
// The number of uniqueness columns must include the RowLocation
// if the user did not specify a unique index.
indexProperties.put("nUniqueColumns",
Integer.toString(unique ? baseColumnPositions.length :
baseColumnPositions.length + 1)
);
// By convention, the row location column is the last column
indexProperties.put("rowLocationColumn",
Integer.toString(baseColumnPositions.length));
// For now, all columns are key fields, including the RowLocation
indexProperties.put("nKeyFields",
Integer.toString(baseColumnPositions.length + 1));
// For now, assume that all index columns are ordered columns
if (! duplicate)
{
indexRowGenerator = new IndexRowGenerator(indexType, unique,
baseColumnPositions,
isAscending,
baseColumnPositions.length);
}