Class CreateIndexConstantAction

  • All Implemented Interfaces:
    ConstantAction

    class CreateIndexConstantAction
    extends IndexConstantAction
    ConstantAction to create an index either through a CREATE INDEX statement or as a backing index to a constraint.
    • Field Detail

      • forCreateTable

        private final boolean forCreateTable
        Is this for a CREATE TABLE, i.e. it is for a constraint declared in a CREATE TABLE statement that requires a backing index.
      • unique

        private boolean unique
      • uniqueWithDuplicateNulls

        private boolean uniqueWithDuplicateNulls
      • uniqueDeferrable

        private boolean uniqueDeferrable
        The index represents a PRIMARY KEY or a UNIQUE NOT NULL constraint which is deferrable. true implies unique == false and uniqueWithDuplicateNulls == false and hasDeferrableChecking == true.
      • hasDeferrableChecking

        private final boolean hasDeferrableChecking
        The index duplicate checking is deferrable. true implies unique == false and (uniqueDeferrable || uniqueWithDuplicateNulls).
      • initiallyDeferred

        private final boolean initiallyDeferred
        Used to determine sorting behavior for existing rows if any
      • constraintType

        private final int constraintType
        The constraint type, see DataDictionary definition of constants.
      • indexType

        private java.lang.String indexType
      • columnNames

        private java.lang.String[] columnNames
      • isAscending

        private boolean[] isAscending
      • isConstraint

        private boolean isConstraint
      • conglomerateUUID

        private UUID conglomerateUUID
      • properties

        private java.util.Properties properties
      • indexTemplateRow

        private ExecRow indexTemplateRow
      • conglomId

        private long conglomId
        Conglomerate number for the conglomerate created by this constant action; -1L if this constant action has not been executed. If this constant action doesn't actually create a new conglomerate--which can happen if it finds an existing conglomerate that satisfies all of the criteria--then this field will hold the conglomerate number of whatever existing conglomerate was found.
      • droppedConglomNum

        private long droppedConglomNum
        Conglomerate number of the physical conglomerate that we will "replace" using this constant action. That is, if the purpose of this constant action is to create a new physical conglomerate to replace a dropped physical conglomerate, then this field holds the conglomerate number of the dropped physical conglomerate. If -1L then we are not replacing a conglomerate, we're simply creating a new index (and backing physical conglomerate) as normal.
    • Constructor Detail

      • CreateIndexConstantAction

        CreateIndexConstantAction​(boolean forCreateTable,
                                  boolean unique,
                                  boolean uniqueWithDuplicateNulls,
                                  boolean hasDeferrableChecking,
                                  boolean initiallyDeferred,
                                  int constraintType,
                                  java.lang.String indexType,
                                  java.lang.String schemaName,
                                  java.lang.String indexName,
                                  java.lang.String tableName,
                                  UUID tableId,
                                  java.lang.String[] columnNames,
                                  boolean[] isAscending,
                                  boolean isConstraint,
                                  UUID conglomerateUUID,
                                  java.util.Properties properties)
        Make the ConstantAction to create an index.
        Parameters:
        forCreateTable - Being executed within a CREATE TABLE statement
        unique - True means it will be a unique index
        uniqueWithDuplicateNulls - True means index check and disallow any duplicate key if key has no column with a null value. If any column in the key has a null value, no checking is done and insert will always succeed.
        hasDeferrableChecking - True means this index backs a deferrable constraint. isConstraint will be true.
        initiallyDeferred - True means the index represents a deferred constraint. Implies hasDeferrableChecking.
        indexType - type of index (BTREE, for example)
        schemaName - schema that table (and index) lives in.
        indexName - Name of the index
        tableName - Name of table the index will be on
        tableId - UUID of table
        columnNames - Names of the columns in the index, in order
        isAscending - Array of booleans telling asc/desc on each column
        isConstraint - TRUE if index is backing up a constraint, else FALSE
        conglomerateUUID - ID of conglomerate
        properties - The optional properties list associated with the index.
      • CreateIndexConstantAction

        CreateIndexConstantAction​(ConglomerateDescriptor srcCD,
                                  TableDescriptor td,
                                  java.util.Properties properties)
        Make a ConstantAction that creates a new physical conglomerate based on index information stored in the received descriptors. Assumption is that the received ConglomerateDescriptor is still valid (meaning it has corresponding entries in the system tables and it describes some constraint/index that has _not_ been dropped--though the physical conglomerate underneath has). This constructor is used in cases where the physical conglomerate for an index has been dropped but the index still exists. That can happen if multiple indexes share a physical conglomerate but then the conglomerate is dropped as part of "drop index" processing for one of the indexes. (Note that "indexes" here includes indexes which were created to back constraints.) In that case we have to create a new conglomerate to satisfy the remaining sharing indexes, so that's what we're here for. See ConglomerateDescriptor.drop() for details on when that is necessary.
    • Method Detail

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object
      • addStatistics

        private boolean addStatistics​(DataDictionary dd,
                                      IndexRowGenerator irg,
                                      long numRows)
                               throws StandardException
        Determines if a statistics entry is to be added for the index.

        As an optimization, it may be better to not write a statistics entry to SYS.SYSSTATISTICS. If it isn't needed by Derby as part of query optimization there is no reason to spend resources keeping the statistics up to date.

        Parameters:
        dd - the data dictionary
        irg - the index row generator
        numRows - the number of rows in the index
        Returns:
        true if statistics should be written to SYS.SYSSTATISTICS, false otherwise.
        Throws:
        StandardException - if accessing the data dictionary fails
      • getIndexTemplateRow

        ExecRow getIndexTemplateRow()
      • getCreatedConglomNumber

        long getCreatedConglomNumber()
        Get the conglomerate number for the conglomerate that was created by this constant action. Will return -1L if the constant action has not yet been executed. This is used for updating conglomerate descriptors which share a conglomerate that has been dropped, in which case those "sharing" descriptors need to point to the newly-created conglomerate (the newly-created conglomerate replaces the dropped one).
      • getReplacedConglomNumber

        long getReplacedConglomNumber()
        If the purpose of this constant action was to "replace" a dropped physical conglomerate, then this method returns the conglomerate number of the dropped conglomerate. Otherwise this method will end up returning -1.
      • getCreatedUUID

        UUID getCreatedUUID()
        Get the UUID for the conglomerate descriptor that was created (or re-used) by this constant action.