Examples with ConglomerateDescriptor org.apache.derby.iapi.sql.dictionary.ConglomerateDescriptor used on opensource projects

Example 1 with ConglomerateDescriptor

use of org.apache.derby.iapi.sql.dictionary.ConglomerateDescriptor in project derby by apache.

the class ConglomInfo method getConglomInfo.

private void getConglomInfo(LanguageConnectionContext lcc) throws StandardException {
    DataDictionary dd = lcc.getDataDictionary();
    if (schemaName == null) {
        schemaName = lcc.getCurrentSchemaName();
    }
    ConglomerateDescriptor[] cds;
    if (tableName != null) {
        // if schemaName is null, it gets the default schema
        SchemaDescriptor sd = dd.getSchemaDescriptor(schemaName, tc, true);
        TableDescriptor td = dd.getTableDescriptor(tableName, sd, tc);
        if (// table does not exist
        td == null) {
            // make empty conglom table
            conglomTable = new ConglomInfo[0];
            return;
        }
        cds = td.getConglomerateDescriptors();
    } else // 0-arg constructor, no table name, get all conglomerates
    {
        cds = dd.getConglomerateDescriptors(null);
    }
    // initialize spaceTable
    conglomTable = new ConglomInfo[cds.length];
    for (int i = 0; i < cds.length; i++) {
        String conglomerateName;
        if (cds[i].isIndex()) {
            conglomerateName = cds[i].getConglomerateName();
        } else if (tableName != null) {
            conglomerateName = tableName;
        } else {
            // 0-arg constructor. need to ask data dictionary for name of table
            conglomerateName = dd.getTableDescriptor(cds[i].getTableID()).getName();
        }
        conglomTable[i] = new ConglomInfo(cds[i].getTableID().toString(), cds[i].getConglomerateNumber(), conglomerateName, cds[i].isIndex());
    }
}

Example 2 with ConglomerateDescriptor

use of org.apache.derby.iapi.sql.dictionary.ConglomerateDescriptor in project derby by apache.

the class ConsistencyChecker method checkTable.

/**
 * Check the named table, ensuring that all of its indexes are consistent
 * with the base table.
 * Use this
 *  method only within an SQL-J statement; do not call it directly.
 * <P>When tables are consistent, the method returns true. Otherwise, the method throws an exception.
 * <p>To check the consistency of a single table:
 * <p><code>
 * VALUES ConsistencyChecker::checkTable(<i>SchemaName</i>, <i>TableName</i>)</code></p>
 * <P>For example, to check the consistency of the table <i>APP.Flights</i>:
 * <p><code>
 * VALUES ConsistencyChecker::checkTable('APP', 'FLIGHTS')</code></p>
 * <p>To check the consistency of all of the tables in the 'APP' schema,
 * stopping at the first failure:
 *
 * <P><code>SELECT tablename, ConsistencyChecker::checkTable(<br>
 * 'APP', tablename)<br>
 * FROM sys.sysschemas s, sys.systables t
 * WHERE s.schemaname = 'APP' AND s.schemaid = t.schemaid</code>
 *
 * <p> To check the consistency of an entire database, stopping at the first failure:
 *
 * <p><code>SELECT schemaname, tablename,<br>
 * ConsistencyChecker::checkTable(schemaname, tablename)<br>
 * FROM sys.sysschemas s, sys.systables t<br>
 * WHERE s.schemaid = t.schemaid</code>
 *
 * @param schemaName	The schema name of the table.
 * @param tableName		The name of the table
 *
 * @return	true, if the table is consistent, exception thrown if inconsistent
 *
 * @exception	SQLException	Thrown if some inconsistency
 *									is found, or if some unexpected
 *									exception is thrown..
 */
public static boolean checkTable(String schemaName, String tableName) throws SQLException {
    DataDictionary dd;
    TableDescriptor td;
    long baseRowCount = -1;
    TransactionController tc;
    ConglomerateDescriptor heapCD;
    ConglomerateDescriptor indexCD;
    ExecRow baseRow;
    ExecRow indexRow;
    RowLocation rl = null;
    RowLocation scanRL = null;
    ScanController scan = null;
    int[] baseColumnPositions;
    int baseColumns = 0;
    DataValueFactory dvf;
    long indexRows;
    ConglomerateController baseCC = null;
    ConglomerateController indexCC = null;
    SchemaDescriptor sd;
    ConstraintDescriptor constraintDesc;
    LanguageConnectionContext lcc = ConnectionUtil.getCurrentLCC();
    tc = lcc.getTransactionExecute();
    try {
        // make sure that application code doesn't bypass security checks
        // by calling this public entry point
        SecurityUtil.authorize(Securable.CHECK_TABLE);
        dd = lcc.getDataDictionary();
        dvf = lcc.getDataValueFactory();
        ExecutionFactory ef = lcc.getLanguageConnectionFactory().getExecutionFactory();
        sd = dd.getSchemaDescriptor(schemaName, tc, true);
        td = dd.getTableDescriptor(tableName, sd, tc);
        if (td == null) {
            throw StandardException.newException(SQLState.LANG_TABLE_NOT_FOUND, schemaName + "." + tableName);
        }
        /* Skip views */
        if (td.getTableType() == TableDescriptor.VIEW_TYPE) {
            return true;
        }
        /* Open the heap for reading */
        baseCC = tc.openConglomerate(td.getHeapConglomerateId(), false, 0, TransactionController.MODE_TABLE, TransactionController.ISOLATION_SERIALIZABLE);
        /* Check the consistency of the heap */
        baseCC.checkConsistency();
        heapCD = td.getConglomerateDescriptor(td.getHeapConglomerateId());
        /* Get a row template for the base table */
        baseRow = ef.getValueRow(td.getNumberOfColumns());
        /* Fill the row with nulls of the correct type */
        ColumnDescriptorList cdl = td.getColumnDescriptorList();
        int cdlSize = cdl.size();
        for (int index = 0; index < cdlSize; index++) {
            ColumnDescriptor cd = (ColumnDescriptor) cdl.elementAt(index);
            baseRow.setColumn(cd.getPosition(), cd.getType().getNull());
        }
        /* Look at all the indexes on the table */
        ConglomerateDescriptor[] cds = td.getConglomerateDescriptors();
        for (int index = 0; index < cds.length; index++) {
            indexCD = cds[index];
            /* Skip the heap */
            if (!indexCD.isIndex())
                continue;
            /* Check the internal consistency of the index */
            indexCC = tc.openConglomerate(indexCD.getConglomerateNumber(), false, 0, TransactionController.MODE_TABLE, TransactionController.ISOLATION_SERIALIZABLE);
            indexCC.checkConsistency();
            indexCC.close();
            indexCC = null;
            if (indexCD.isConstraint()) {
                constraintDesc = dd.getConstraintDescriptor(td, indexCD.getUUID());
                if (constraintDesc == null) {
                    throw StandardException.newException(SQLState.LANG_OBJECT_NOT_FOUND, "CONSTRAINT for INDEX", indexCD.getConglomerateName());
                }
            }
            /*
				** Set the base row count when we get to the first index.
				** We do this here, rather than outside the index loop, so
				** we won't do the work of counting the rows in the base table
				** if there are no indexes to check.
				*/
            if (baseRowCount < 0) {
                scan = tc.openScan(heapCD.getConglomerateNumber(), // hold
                false, // not forUpdate
                0, TransactionController.MODE_TABLE, TransactionController.ISOLATION_SERIALIZABLE, RowUtil.EMPTY_ROW_BITSET, // startKeyValue
                null, // not used with null start posn.
                0, // qualifier
                null, // stopKeyValue
                null, // not used with null stop posn.
                0);
                /* Also, get the row location template for index rows */
                rl = scan.newRowLocationTemplate();
                scanRL = scan.newRowLocationTemplate();
                for (baseRowCount = 0; scan.next(); baseRowCount++) ;
                /* Empty statement */
                scan.close();
                scan = null;
            }
            baseColumnPositions = indexCD.getIndexDescriptor().baseColumnPositions();
            baseColumns = baseColumnPositions.length;
            FormatableBitSet indexColsBitSet = new FormatableBitSet();
            for (int i = 0; i < baseColumns; i++) {
                indexColsBitSet.grow(baseColumnPositions[i]);
                indexColsBitSet.set(baseColumnPositions[i] - 1);
            }
            /* Get one row template for the index scan, and one for the fetch */
            indexRow = ef.getValueRow(baseColumns + 1);
            /* Fill the row with nulls of the correct type */
            for (int column = 0; column < baseColumns; column++) {
                /* Column positions in the data dictionary are one-based */
                ColumnDescriptor cd = td.getColumnDescriptor(baseColumnPositions[column]);
                indexRow.setColumn(column + 1, cd.getType().getNull());
            }
            /* Set the row location in the last column of the index row */
            indexRow.setColumn(baseColumns + 1, rl);
            /* Do a full scan of the index */
            scan = tc.openScan(indexCD.getConglomerateNumber(), // hold
            false, // not forUpdate
            0, TransactionController.MODE_TABLE, TransactionController.ISOLATION_SERIALIZABLE, (FormatableBitSet) null, // startKeyValue
            null, // not used with null start posn.
            0, // qualifier
            null, // stopKeyValue
            null, // not used with null stop posn.
            0);
            DataValueDescriptor[] baseRowIndexOrder = new DataValueDescriptor[baseColumns];
            DataValueDescriptor[] baseObjectArray = baseRow.getRowArray();
            for (int i = 0; i < baseColumns; i++) {
                baseRowIndexOrder[i] = baseObjectArray[baseColumnPositions[i] - 1];
            }
            /* Get the index rows and count them */
            for (indexRows = 0; scan.fetchNext(indexRow.getRowArray()); indexRows++) {
                /*
					** Get the base row using the RowLocation in the index row,
					** which is in the last column.  
					*/
                RowLocation baseRL = (RowLocation) indexRow.getColumn(baseColumns + 1);
                boolean base_row_exists = baseCC.fetch(baseRL, baseObjectArray, indexColsBitSet);
                /* Throw exception if fetch() returns false */
                if (!base_row_exists) {
                    String indexName = indexCD.getConglomerateName();
                    throw StandardException.newException(SQLState.LANG_INCONSISTENT_ROW_LOCATION, (schemaName + "." + tableName), indexName, baseRL.toString(), indexRow.toString());
                }
                /* Compare all the column values */
                for (int column = 0; column < baseColumns; column++) {
                    DataValueDescriptor indexColumn = indexRow.getColumn(column + 1);
                    DataValueDescriptor baseColumn = baseRowIndexOrder[column];
                    /*
						** With this form of compare(), null is considered equal
						** to null.
						*/
                    if (indexColumn.compare(baseColumn) != 0) {
                        ColumnDescriptor cd = td.getColumnDescriptor(baseColumnPositions[column]);
                        throw StandardException.newException(SQLState.LANG_INDEX_COLUMN_NOT_EQUAL, indexCD.getConglomerateName(), td.getSchemaName(), td.getName(), baseRL.toString(), cd.getColumnName(), indexColumn.toString(), baseColumn.toString(), indexRow.toString());
                    }
                }
            }
            /* Clean up after the index scan */
            scan.close();
            scan = null;
            /*
				** The index is supposed to have the same number of rows as the
				** base conglomerate.
				*/
            if (indexRows != baseRowCount) {
                throw StandardException.newException(SQLState.LANG_INDEX_ROW_COUNT_MISMATCH, indexCD.getConglomerateName(), td.getSchemaName(), td.getName(), Long.toString(indexRows), Long.toString(baseRowCount));
            }
        }
        /* check that all constraints have backing index */
        ConstraintDescriptorList constraintDescList = dd.getConstraintDescriptors(td);
        for (int index = 0; index < constraintDescList.size(); index++) {
            constraintDesc = constraintDescList.elementAt(index);
            if (constraintDesc.hasBackingIndex()) {
                ConglomerateDescriptor conglomDesc;
                conglomDesc = td.getConglomerateDescriptor(constraintDesc.getConglomerateId());
                if (conglomDesc == null) {
                    throw StandardException.newException(SQLState.LANG_OBJECT_NOT_FOUND, "INDEX for CONSTRAINT", constraintDesc.getConstraintName());
                }
            }
        }
    } catch (StandardException se) {
        throw PublicAPI.wrapStandardException(se);
    } finally {
        try {
            /* Clean up before we leave */
            if (baseCC != null) {
                baseCC.close();
                baseCC = null;
            }
            if (indexCC != null) {
                indexCC.close();
                indexCC = null;
            }
            if (scan != null) {
                scan.close();
                scan = null;
            }
        } catch (StandardException se) {
            throw PublicAPI.wrapStandardException(se);
        }
    }
    return true;
}

Example 3 with ConglomerateDescriptor

use of org.apache.derby.iapi.sql.dictionary.ConglomerateDescriptor in project derby by apache.

the class DataDictionaryImpl method addSystemTableToDictionary.

/**
 *		Add the required entries to the data dictionary for a System table.
 */
private void addSystemTableToDictionary(TabInfoImpl ti, SchemaDescriptor sd, TransactionController tc, DataDescriptorGenerator ddg) throws StandardException {
    CatalogRowFactory crf = ti.getCatalogRowFactory();
    String name = ti.getTableName();
    long conglomId = ti.getHeapConglomerate();
    SystemColumn[] columnList = crf.buildColumnList();
    UUID heapUUID = crf.getCanonicalHeapUUID();
    String heapName = crf.getCanonicalHeapName();
    TableDescriptor td;
    UUID toid;
    int columnCount;
    SystemColumn column;
    // add table to the data dictionary
    columnCount = columnList.length;
    td = ddg.newTableDescriptor(name, sd, TableDescriptor.SYSTEM_TABLE_TYPE, TableDescriptor.ROW_LOCK_GRANULARITY);
    td.setUUID(crf.getCanonicalTableUUID());
    addDescriptor(td, sd, SYSTABLES_CATALOG_NUM, false, tc);
    toid = td.getUUID();
    /* Add the conglomerate for the heap */
    ConglomerateDescriptor cgd = ddg.newConglomerateDescriptor(conglomId, heapName, false, null, false, heapUUID, toid, sd.getUUID());
    addDescriptor(cgd, sd, SYSCONGLOMERATES_CATALOG_NUM, false, tc);
    /* Create the columns */
    ColumnDescriptor[] cdlArray = new ColumnDescriptor[columnCount];
    for (int columnNumber = 0; columnNumber < columnCount; columnNumber++) {
        column = columnList[columnNumber];
        if (SanityManager.DEBUG) {
            if (column == null) {
                SanityManager.THROWASSERT("column " + columnNumber + " for table " + ti.getTableName() + " is null");
            }
        }
        cdlArray[columnNumber] = makeColumnDescriptor(column, columnNumber + 1, td);
    }
    addDescriptorArray(cdlArray, td, SYSCOLUMNS_CATALOG_NUM, false, tc);
    // now add the columns to the cdl of the table.
    ColumnDescriptorList cdl = td.getColumnDescriptorList();
    for (int i = 0; i < columnCount; i++) cdl.add(cdlArray[i]);
}

Example 4 with ConglomerateDescriptor

use of org.apache.derby.iapi.sql.dictionary.ConglomerateDescriptor in project derby by apache.

the class DataDictionaryImpl method faultInTabInfo.

/**
 *	Finishes building a TabInfoImpl if it hasn't already been faulted in.
 *	NOP if TabInfoImpl has already been faulted in.
 *
 *	@param	ti	TabInfoImpl to fault in.
 *
 * @exception StandardException		Thrown on error
 */
private void faultInTabInfo(TabInfoImpl ti) throws StandardException {
    int numIndexes;
    /* Most of the time, the noncoreInfo will be complete.
		 * It's okay to do an unsynchronized check and return
		 * if it is complete, since it never becomes "un-complete".
		 * If we change the code, for some reason, to allow
		 * it to become "un-complete" after being complete,
		 * then we will have to do a synchronized check here
		 * as well.
		 */
    if (ti.isComplete()) {
        return;
    }
    /* The completing of the noncoreInfo entry must be synchronized. 
		 * NOTE: We are assuming that we will not access a different
		 * noncoreInfo in the course of completing of this noncoreInfo,
		 * otherwise a deadlock could occur.
		 */
    synchronized (ti) {
        /* Now that we can run, the 1st thing that we must do
			 * is to verify that we still need to complete the
			 * object.  (We may have been blocked on another user
			 * doing the same.)
			 */
        if (ti.isComplete()) {
            return;
        }
        TableDescriptor td = getTableDescriptor(ti.getTableName(), getSystemSchemaDescriptor(), null);
        // exception.
        if (td == null) {
            return;
        }
        ConglomerateDescriptor cd = null;
        ConglomerateDescriptor[] cds = td.getConglomerateDescriptors();
        /* Init the heap conglomerate here */
        for (int index = 0; index < cds.length; index++) {
            cd = cds[index];
            if (!cd.isIndex()) {
                ti.setHeapConglomerate(cd.getConglomerateNumber());
                break;
            }
        }
        if (SanityManager.DEBUG) {
            if (cd == null) {
                SanityManager.THROWASSERT("No heap conglomerate found for " + ti.getTableName());
            }
        }
        /* Initialize the index conglomerates */
        numIndexes = ti.getCatalogRowFactory().getNumIndexes();
        if (numIndexes == 0) {
            return;
        }
        /* For each index, we get its id from the CDL */
        ConglomerateDescriptor icd = null;
        int indexCount = 0;
        for (int index = 0; index < cds.length; index++) {
            icd = cds[index];
            if (icd.isIndex()) {
                ti.setIndexConglomerate(icd);
                indexCount++;
            }
            continue;
        }
        if (SanityManager.DEBUG) {
            if (indexCount != ti.getCatalogRowFactory().getNumIndexes()) {
                SanityManager.THROWASSERT("Number of indexes found (" + indexCount + ") does not match the number expected (" + ti.getCatalogRowFactory().getNumIndexes() + ")");
            }
        }
    }
}

Example 5 with ConglomerateDescriptor

use of org.apache.derby.iapi.sql.dictionary.ConglomerateDescriptor in project derby by apache.

the class DataDictionaryImpl method bootstrapOneIndex.

private ConglomerateDescriptor bootstrapOneIndex(SchemaDescriptor sd, TransactionController tc, DataDescriptorGenerator ddg, TabInfoImpl ti, int indexNumber, long heapConglomerateNumber) throws StandardException {
    boolean isUnique;
    ConglomerateController cc;
    ExecRow baseRow;
    ExecIndexRow indexableRow;
    int numColumns;
    long conglomId;
    RowLocation rl;
    CatalogRowFactory rf = ti.getCatalogRowFactory();
    IndexRowGenerator irg;
    ConglomerateDescriptor conglomerateDescriptor;
    initSystemIndexVariables(ti, indexNumber);
    irg = ti.getIndexRowGenerator(indexNumber);
    numColumns = ti.getIndexColumnCount(indexNumber);
    /* Is the index unique */
    isUnique = ti.isIndexUnique(indexNumber);
    // create an index row template
    indexableRow = irg.getIndexRowTemplate();
    baseRow = rf.makeEmptyRowForCurrentVersion();
    // Get a RowLocation template
    cc = tc.openConglomerate(heapConglomerateNumber, false, 0, TransactionController.MODE_RECORD, TransactionController.ISOLATION_REPEATABLE_READ);
    rl = cc.newRowLocationTemplate();
    cc.close();
    // Get an index row based on the base row
    irg.getIndexRow(baseRow, rl, indexableRow, (FormatableBitSet) null);
    // Describe the properties of the index to the store using Properties
    // RESOLVE: The following properties assume a BTREE index.
    Properties indexProperties = ti.getCreateIndexProperties(indexNumber);
    // Tell it the conglomerate id of the base table
    indexProperties.put("baseConglomerateId", Long.toString(heapConglomerateNumber));
    // 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(isUnique ? numColumns : numColumns + 1));
    // By convention, the row location column is the last column
    indexProperties.put("rowLocationColumn", Integer.toString(numColumns));
    // For now, all columns are key fields, including the RowLocation
    indexProperties.put("nKeyFields", Integer.toString(numColumns + 1));
    /* Create and add the conglomerate (index) */
    conglomId = tc.createConglomerate(// we're requesting an index conglomerate
    "BTREE", indexableRow.getRowArray(), // default sort order
    null, // default collation id's for collumns in all system congloms
    null, // default properties
    indexProperties, // not temporary
    TransactionController.IS_DEFAULT);
    conglomerateDescriptor = ddg.newConglomerateDescriptor(conglomId, rf.getIndexName(indexNumber), true, irg, false, rf.getCanonicalIndexUUID(indexNumber), rf.getCanonicalTableUUID(), sd.getUUID());
    ti.setIndexConglomerate(conglomerateDescriptor);
    return conglomerateDescriptor;
}