com.splicemachine.derby.impl.sql.execute.actions

Class CreateIndexConstantOperation

java.lang.Object

com.splicemachine.derby.impl.sql.execute.actions.DDLConstantOperation

com.splicemachine.derby.impl.sql.execute.actions.DDLSingleTableConstantOperation

com.splicemachine.derby.impl.sql.execute.actions.IndexConstantOperation

com.splicemachine.derby.impl.sql.execute.actions.CreateIndexConstantOperation

All Implemented Interfaces:

ConstantAction, ScopeNamed, java.io.Serializable

public class CreateIndexConstantOperation
extends IndexConstantOperation
implements java.io.Serializable

Creates an Index transactionally. Index creation is separated into 3 phases: 1. Metadata 2. Global Create 3. Global populate

Metadata Phase

This phase is where the index elements are added to various system tables. Not much going on here, it's mostly the same as what Derby does--it will look for a duplicate index (e.g. if some other index already covers the data in the proper order), create the conglomerate and so on and so forth.

Create Phase

This phase is where we notify all the other servers in the cluster that the index has been created. We do this by using a child transaction and the task framework to ensure that all nodes have invalidated their Data Dictionary, and that the Write pipeline is notified of the change in the structure.

Populate Phase

This phase is where pre-existing data is indexed properly (and it usually occupies the most time). This occurs within a child transaction.

Transactional State

First, note that the entire operation occurs within the context of an internal transaction, which is committed or aborted based on the output of the three phases. In this way, the behavior of the user transaction is taken out of consideration. Henceforth, we will use the term "parent" to refer to this internal transaction. We have a tricky needle to thread transactionally. On the one hand, we add a filter to the write pipeline so that new transactions (transactions which have a begin timestamp > ours). On the other, we use a populate task to ensure that data which was already present from old transactions will be populated as well. But what about transactions which are created during the process? Consider the following time sequences: Scenario 1: Before Create The sequence is as follows:

1. Parent transaction is created (Tp = [bp,...))
2. Independent transaction is created (To = [bo,...) such that bp < bo)
3. To commits (To = [bo,co))
4. Create transaction is created as child of parent (Tc = [bc,...),Tc.parent = Tp)
5. Create transaction is committed at cc(Tc = [bc,cc))
6. Populate transaction is created and committed as child of parent (Tpop = [bpop,cpop),Tpop.parent = Tp)

In this case, we expect that the writes from the independent transaction will not have been picked up by the interceptor that we place during the create phase (as the create phase has not happened yet). Therefore the independent transaction's writes need to be picked up by the populate child transaction--this is a variant on Snapshot isolation--instead of doing a full Snapshot Isolation reading level, we require that data must be committed before the start of the population phase. On the other hand, consider this second scenario: Scenario 2: Between Creation and Population The sequence is:

1. Tp created (Tp = [bp,...)).
2. Create transaction Tc is created (Tc = [bc,...), Tc.parent = Tp)
3. Create transaction Tc is committed (Tc = [bc,cc))
4. Independent Transaction To = [bo,...) is created such that cc < bo
5. Independent Transaction To is committed (To = [bo,co))
6. Populate Transaction is created and committed.

In this scenario, the independent transaction was created after the create transaction was committed--therefore, we should be able to make the guarantee that the write pipeline interceptor will catch the write and transform it directly; as a result, the populate task cannot see this write. Unfortunately, Scenarios #1 and #2 conflict. In both cases we have an independent transaction which committed before the start of the Populate phase, but in one the writes need to be visible, while in the other they cannot be. We resolve this issue by chaining the create and populate transactions together. Transaction chaining is where we commit one transaction, then create a new transaction whose begin timestamp is the same as the commit timestamp of the committed transaction. For example, we create a transaction at time 1, then chain commit that transaction. In that case, the commit timestamp if 2, and the new transaction's begin timestamp is 2. Thus, there is no possibility of another transaction interleaving with the operation-- the transactions are "contiguous in time".

See Also:

Serialized Form

Field Summary

Fields inherited from class com.splicemachine.derby.impl.sql.execute.actions.IndexConstantOperation

indexName, schemaName, tableName

Fields inherited from class com.splicemachine.derby.impl.sql.execute.actions.DDLSingleTableConstantOperation

tableId

Constructor Summary

Constructors

Constructor and Description
CreateIndexConstantOperation()
CreateIndexConstantOperation(boolean forCreateTable, boolean unique, boolean uniqueWithDuplicateNulls, 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, boolean excludeNulls, boolean excludeDefaults, boolean preSplit, boolean sampling, java.lang.String splitKeyPath, java.lang.String hfilePath, java.lang.String columnDelimiter, java.lang.String characterDelimiter, java.lang.String timestampFormat, java.lang.String dateFormat, java.lang.String timeFormat, java.util.Properties properties) Make the ConstantAction to create an index.
CreateIndexConstantOperation(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.

Method Summary

Modifier and Type	Method and Description
void	executeConstantAction(Activation activation) This is the guts of the Execution-time logic for creating an index.
long	getCreatedConglomNumber() Get the conglomerate number for the conglomerate that was created by this constant action.
UUID	getCreatedUUID() Get the UUID for the conglomerate descriptor that was created (or re-used) by this constant action.
ExecRow	getIndexTemplateRow()
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.
java.lang.String	toString()
protected boolean	waitsForConcurrentTransactions() Declares whether this DDL operation has to wait for the draining of concurrent transactions or not

Methods inherited from class com.splicemachine.derby.impl.sql.execute.actions.IndexConstantOperation

beginChildTransaction, getIndexName, getScopeName, populateIndex, setIndexName

Methods inherited from class com.splicemachine.derby.impl.sql.execute.actions.DDLSingleTableConstantOperation

dropConglomerate, dropConglomerate, dropConstraint, dropConstraint, dropConstraint, dropIndex, executeConglomReplacement, getConglomReplacementAction, recreateUniqueConstraintBackingIndexAsUniqueWhenNotNull

Methods inherited from class com.splicemachine.derby.impl.sql.execute.actions.DDLConstantOperation

addColumnDependencies, adjustUDTDependencies, adjustUDTDependencies, constructToString, getAndCheckSchemaDescriptor, getBlockedTables, getSchemaDescriptorForCreate, noGrantCheck, noRevokeCheck, storeConstraintDependenciesOnPrivileges, storeViewTriggerDependenciesOnPrivileges, waitForConcurrentTransactions

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

CreateIndexConstantOperation

public CreateIndexConstantOperation()

CreateIndexConstantOperation

public CreateIndexConstantOperation(boolean forCreateTable,
                                    boolean unique,
                                    boolean uniqueWithDuplicateNulls,
                                    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,
                                    boolean excludeNulls,
                                    boolean excludeDefaults,
                                    boolean preSplit,
                                    boolean sampling,
                                    java.lang.String splitKeyPath,
                                    java.lang.String hfilePath,
                                    java.lang.String columnDelimiter,
                                    java.lang.String characterDelimiter,
                                    java.lang.String timestampFormat,
                                    java.lang.String dateFormat,
                                    java.lang.String timeFormat,
                                    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.

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.

CreateIndexConstantOperation

CreateIndexConstantOperation(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

executeConstantAction

public void executeConstantAction(Activation activation)
                           throws StandardException

This is the guts of the Execution-time logic for creating an index.

A index is represented as:

• ConglomerateDescriptor.

No dependencies are created.

Specified by:

executeConstantAction in interface ConstantAction

Parameters:

activation - The execution environment for this constant action.

Throws:

StandardException - Thrown on failure

See Also:

ConglomerateDescriptor, SchemaDescriptor, ConstantAction.executeConstantAction(com.splicemachine.db.iapi.sql.Activation)

getIndexTemplateRow

public ExecRow getIndexTemplateRow()

getCreatedConglomNumber

public 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

public 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

public UUID getCreatedUUID()

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

waitsForConcurrentTransactions

protected boolean waitsForConcurrentTransactions()

Description copied from class: DDLConstantOperation

Declares whether this DDL operation has to wait for the draining of concurrent transactions or not

Overrides:

waitsForConcurrentTransactions in class DDLConstantOperation

Returns:

true if it has to wait for the draining of concurrent transactions