Class DMLModStatementNode

    • Field Detail

      • targetVTI

        protected FromVTI targetVTI
      • targetTableName

        protected TableName targetTableName
      • lockMode

        protected int lockMode
      • fkInfo

        protected FKInfo[] fkInfo
      • indexConglomerateNumbers

        public long[] indexConglomerateNumbers
      • indexNames

        public java.lang.String[] indexNames
      • requiresDeferredProcessing

        private boolean requiresDeferredProcessing
      • statementType

        private int statementType
      • bound

        private boolean bound
      • checkConstraints

        private ValueNode checkConstraints
      • fkSchemaNames

        protected java.lang.String[] fkSchemaNames
      • fkTableNames

        protected java.lang.String[] fkTableNames
      • fkRefActions

        protected int[] fkRefActions
      • fkIndexConglomNumbers

        protected long[] fkIndexConglomNumbers
      • isDependentTable

        protected boolean isDependentTable
      • fkColArrays

        protected int[][] fkColArrays
      • synonymTableName

        protected TableName synonymTableName
      • dependentTables

        java.util.Set<java.lang.String> dependentTables
        Set of dependent tables for cascading deletes.
    • Constructor Detail

      • DMLModStatementNode

        DMLModStatementNode​(ResultSetNode resultSet,
                            MatchingClauseNode matchingClause,
                            int statementType,
                            ContextManager cm)
        Constructor for a DMLModStatementNode -- delegate to DMLStatementNode
        Parameters:
        resultSet - A ResultSetNode for the result set of the DML statement
        matchingClause - Non-null if this DML is part of a MATCHED clause of a MERGE statement.
        statementType - used by nodes that allocate a DMLMod directly (rather than inheriting it).
        cm - The context manager
    • Method Detail

      • inMatchingClause

        public boolean inMatchingClause()
        Returns true if this DMLModStatement a [ NOT ] MATCHED action of a MERGE statement
      • generateCodeForTemporaryTable

        protected void generateCodeForTemporaryTable​(ActivationClassBuilder acb)
                                              throws StandardException
        If the DML is on a temporary table, generate the code to mark temporary table as modified in the current UOW. At rollback transaction (or savepoint), we will check if the temporary table was modified in that UOW. If yes, we will remove all the data from the temporary table
        Parameters:
        acb - The ActivationClassBuilder for the class being built
        Throws:
        StandardException - Thrown on error
      • verifyTargetTable

        void verifyTargetTable()
                        throws StandardException
        Verify the target table. Get the TableDescriptor if the target table is not a VTI.
        Throws:
        StandardException - Thrown on error
      • isAtomic

        public boolean isAtomic()
        INSERT/UPDATE/DELETE are always atomic.
        Overrides:
        isAtomic in class DMLStatementNode
        Returns:
        true
      • getSchemaDescriptor

        SchemaDescriptor getSchemaDescriptor()
                                      throws StandardException
        Get a schema descriptor for the given table. Uses this.targetTableName.
        Returns:
        Schema Descriptor
        Throws:
        StandardException - throws on schema name that doesn't exist
      • getReadColMap

        static int[] getReadColMap​(int column_map_length,
                                   FormatableBitSet readColsBitSet)
        Get a map to efficiently find heap columns from a compressed set of read columns. The returns a map such that
                  map[heapColId (0 based)] -> readCol id (0 based)
                  
        Parameters:
        column_map_length - The number of columns(ints) in the map.
        readColsBitSet - A language style (1 based) bit set with bits for read heap columns set. RESOLVE: Replace this with a call to RowUtil when the store and the language both use 0 base or 1 base offsets for columns. Today we can't use the store function because we have a 1 based FormatableBitSet.
      • getResultColumnList

        protected void getResultColumnList()
                                    throws StandardException
        Get and bind the ResultColumnList representing the columns in the target table, given the table's name.
        Throws:
        StandardException - Thrown on error
      • parseAndBindGenerationClauses

        void parseAndBindGenerationClauses​(DataDictionary dataDictionary,
                                           TableDescriptor targetTableDescriptor,
                                           ResultColumnList sourceRCL,
                                           ResultColumnList targetRCL,
                                           boolean forUpdate,
                                           ResultSetNode updateResultSet)
                                    throws StandardException
        Parse and bind the generating expressions of computed columns.
        Parameters:
        dataDictionary - metadata
        targetTableDescriptor - metadata for the table that has the generated columns
        sourceRCL - the tuple stream which drives the INSERT or UPDATE
        targetRCL - the row in the table that's being INSERTed or UPDATEd
        forUpdate - true if this is an UPDATE. false otherwise.
        updateResultSet - more information on the tuple stream driving the UPDATE
        Throws:
        StandardException
      • parseGenerationClause

        public ValueNode parseGenerationClause​(java.lang.String clauseText,
                                               TableDescriptor td)
                                        throws StandardException
        Parse the generation clause for a column.
        Parameters:
        clauseText - Text of the generation clause
        Returns:
        The parsed expression as a query tree.
        Throws:
        StandardException - Thrown on failure
      • bindConstraints

        ValueNode bindConstraints​(DataDictionary dataDictionary,
                                  OptimizerFactory optimizerFactory,
                                  TableDescriptor targetTableDescriptor,
                                  Dependent dependent,
                                  ResultColumnList sourceRCL,
                                  int[] changedColumnIds,
                                  FormatableBitSet readColsBitSet,
                                  boolean includeTriggers,
                                  boolean[] hasDeferrableCheckConstraints)
                           throws StandardException
        Gets and binds all the constraints for an INSERT/UPDATE/DELETE. First finds the constraints that are relevant to this node. This is done by calling getAllRelevantConstriants(). If getAllRelevantConstraints() has already been called, then this list is used. Then it creates appropriate dependencies. Then binds check constraints. It also generates the array of FKInfo items that are used in code generation. Note: we have a new flag here to see if defer processing is enabled or not, the only scenario that is disabled is when we reapply the reply message we get from the source
        Parameters:
        dataDictionary - The DataDictionary
        targetTableDescriptor - The TableDescriptor
        dependent - Parent object that will depend on all the constraints that we look up. If this argument is null, then we use the default dependent (the statement being compiled).
        sourceRCL - RCL of the table being changed
        changedColumnIds - If null, all columns being changed, otherwise array of 1-based column ids for columns being changed
        readColsBitSet - bit set for the read scan
        includeTriggers - whether triggers are included in the processing
        hasDeferrableCheckConstraints - OUT semantics: set element 0 to true if the target table has any deferrable CHECK constraints
        Returns:
        The bound, ANDed check constraints as a query tree.
        Throws:
        StandardException - Thrown on failure
      • bindRowScopedExpression

        static void bindRowScopedExpression​(OptimizerFactory optimizerFactory,
                                            ContextManager cm,
                                            TableDescriptor targetTableDescriptor,
                                            ResultColumnList sourceRCL,
                                            ValueNode expression)
                                     throws StandardException
        Binds an already parsed expression that only involves columns in a single row. E.g., a check constraint or a generation clause.
        Parameters:
        optimizerFactory - The optimizer factory
        cm - The context manager
        targetTableDescriptor - The TableDescriptor for the constrained table
        sourceRCL - Result columns
        expression - Parsed query tree for row scoped expression
        Throws:
        StandardException - Thrown on failure
      • hasCheckConstraints

        protected boolean hasCheckConstraints​(DataDictionary dd,
                                              TableDescriptor td)
                                       throws StandardException
        Determine whether or not there are check constraints on the specified table.
        Parameters:
        dd - The DataDictionary to use
        td - The TableDescriptor for the table
        Returns:
        Whether or not there are check constraints on the specified table.
        Throws:
        StandardException - Thrown on failure
      • hasGenerationClauses

        protected boolean hasGenerationClauses​(TableDescriptor td)
                                        throws StandardException
        Determine whether or not there are generated columns in the specified table.
        Parameters:
        td - The TableDescriptor for the table
        Returns:
        Whether or not there are generated columns in the specified table.
        Throws:
        StandardException - Thrown on failure
      • generateCheckTree

        private ValueNode generateCheckTree​(ConstraintDescriptorList cdl,
                                            TableDescriptor td,
                                            boolean[] hasDeferrable)
                                     throws StandardException
        Get the ANDing of all appropriate check constraints as 1 giant query tree. Makes the calling object (usually a Statement) dependent on all the constraints.
        Parameters:
        cdl - The constraint descriptor list
        td - The TableDescriptor
        Returns:
        The ANDing of all appropriate check constraints as a query tree.
        Throws:
        StandardException - Thrown on failure
      • generateFKInfo

        private void generateFKInfo​(ConstraintDescriptorList cdl,
                                    DataDictionary dd,
                                    TableDescriptor td,
                                    FormatableBitSet readColsBitSet)
                             throws StandardException
        Generate the FKInfo structures used during code generation. For each constraint that isn't a check constraint, add another one of these FKInfo structures and then package them up into a single array.
        Parameters:
        cdl - The constraint descriptor list
        dd - The DataDictionary
        td - The TableDescriptor
        readColsBitSet - columns read
        Throws:
        StandardException - Thrown on failure
      • generateTriggerInfo

        private void generateTriggerInfo​(TriggerDescriptorList triggerList)
        Generate the TriggerInfo structures used during code generation.
        Parameters:
        triggerList - The trigger descriptor list
      • getFKInfo

        FKInfo[] getFKInfo()
        Return the FKInfo structure. Just a little wrapper to make sure we don't try to access it until after binding.
        Returns:
        the array of fkinfos
      • getTriggerInfo

        TriggerInfo getTriggerInfo()
        Return the TriggerInfo structure. Just a little wrapper to make sure we don't try to access it until after binding.
        Returns:
        the trigger info
      • getCheckConstraints

        ValueNode getCheckConstraints()
        Get the check constraints for this node
        Returns:
        the check constraints, may be null
      • createTriggerDependencies

        private void createTriggerDependencies​(TriggerDescriptorList tdl,
                                               Dependent dependent)
                                        throws StandardException
        Makes the calling object (usually a Statement) dependent on all the constraints.
        Parameters:
        tdl - The trigger descriptor list
        dependent - Parent object that will depend on all the constraints that we look up. If this argument is null, then we use the default dependent (the statement being compiled).
        Throws:
        StandardException - Thrown on failure
      • getAllRelevantTriggers

        protected TriggerDescriptorList getAllRelevantTriggers​(DataDictionary dd,
                                                               TableDescriptor td,
                                                               int[] changedColumnIds,
                                                               boolean includeTriggers)
                                                        throws StandardException
        Get all the triggers relevant to this DML operation
        Parameters:
        dd - The data dictionary
        td - The TableDescriptor
        changedColumnIds - If null, all columns being changed, otherwise array of 1-based column ids for columns being changed
        includeTriggers - whether we allow trigger processing or not for this table
        Returns:
        the constraint descriptor list
        Throws:
        StandardException - Thrown on failure
      • adjustDeferredFlag

        protected void adjustDeferredFlag​(boolean adjustment)
      • createConstraintDependencies

        private void createConstraintDependencies​(DataDictionary dd,
                                                  ConstraintDescriptorList cdl,
                                                  Dependent dependent)
                                           throws StandardException
        Get all of our dependents due to a constraint. Makes the calling object (usually a Statement) dependent on all the constraints.
        Parameters:
        dd - The data dictionary
        cdl - The constraint descriptor list
        dependent - Parent object that will depend on all the constraints that we look up. If this argument is null, then we use the default dependent (the statement being compiled).
        Throws:
        StandardException - Thrown on failure
      • getAllRelevantConstraints

        protected ConstraintDescriptorList getAllRelevantConstraints​(DataDictionary dd,
                                                                     TableDescriptor td,
                                                                     int[] changedColumnIds)
                                                              throws StandardException
        Get all the constraints relevant to this DML operation
        Parameters:
        dd - The DataDictionary
        td - The TableDescriptor
        changedColumnIds - If null, all columns being changed, otherwise array of 1-based column ids for columns being changed
        Returns:
        the constraint descriptor list
        Throws:
        StandardException - Thrown on failure
      • requiresDeferredProcessing

        boolean requiresDeferredProcessing()
        Does this DML Node require deferred processing? Set to true if we have triggers or referential constraints that need deferred processing.
        Returns:
        true/false
      • parseCheckConstraint

        public ValueNode parseCheckConstraint​(java.lang.String checkConstraintText,
                                              TableDescriptor td)
                                       throws StandardException
        Parse a check constraint and turn it into a query tree.
        Parameters:
        checkConstraintText - Text of CHECK CONSTRAINT.
        td - The TableDescriptor for the table the the constraint is on.
        Returns:
        The parsed check constraint as a query tree.
        Throws:
        StandardException - Thrown on failure
      • generateGenerationClauses

        public void generateGenerationClauses​(ResultColumnList rcl,
                                              int resultSetNumber,
                                              boolean isUpdate,
                                              ExpressionClassBuilder ecb,
                                              MethodBuilder mb)
                                       throws StandardException
        Generate the code to evaluate all of the generation clauses. If there are generation clauses, this routine builds an Activation method which evaluates the generation clauses and fills in the computed columns.
        Parameters:
        rcl - describes the row of expressions to be put into the bas table
        resultSetNumber - index of base table into array of ResultSets
        isUpdate - true if this is for an UPDATE statement
        ecb - code generation state variable
        mb - the method being generated
        Throws:
        StandardException - Thrown on error
      • generateGenerationClauses

        private MethodBuilder generateGenerationClauses​(ResultColumnList rcl,
                                                        int rsNumber,
                                                        boolean isUpdate,
                                                        ExpressionClassBuilder ecb)
                                                 throws StandardException
        Generate a method to compute all of the generation clauses in a row.
        Parameters:
        rcl - describes the row of expressions to be put into the bas table
        rsNumber - index of base table into array of ResultSets
        isUpdate - true if this is for an UPDATE statement
        ecb - code generation state variable
        Throws:
        StandardException
      • optimizeStatement

        public void optimizeStatement()
                               throws StandardException
        Generate an optimized QueryTree from a bound QueryTree. Actually, it can annotate the tree in place rather than generate a new tree, but this interface allows the root node of the optimized QueryTree to be different from the root node of the bound QueryTree. For non-optimizable statements, this method is a no-op. Throws an exception if the tree is not bound, or if the binding is out of date.
        Overrides:
        optimizeStatement in class DMLStatementNode
        Throws:
        StandardException - Thrown on failure
      • getAffectedIndexes

        protected void getAffectedIndexes​(TableDescriptor td,
                                          ResultColumnList updatedColumns,
                                          FormatableBitSet colBitSet)
                                   throws StandardException
        Get the list of indexes that must be updated by this DML statement. WARNING: As a side effect, it creates dependencies on those indexes.
        Parameters:
        td - The table descriptor for the table being updated
        updatedColumns - The updated column list. If not update, null
        colBitSet - a 1 based bit set of the columns in the list
        Throws:
        StandardException - Thrown on error
      • getXAffectedIndexes

        static void getXAffectedIndexes​(TableDescriptor baseTable,
                                        ResultColumnList updatedColumns,
                                        FormatableBitSet colBitSet,
                                        java.util.List<ConglomerateDescriptor> conglomerates)
                                 throws StandardException
        Marks which indexes are affected by an UPDATE of the desired shape. Is passed a list of updated columns. Does the following: 1) finds all indices which overlap the updated columns 2) adds the index columns to a bitmap of affected columns 3) adds the index descriptors to a list of conglomerate descriptors.
        Parameters:
        updatedColumns - a list of updated columns
        colBitSet - OUT: evolving bitmap of affected columns
        conglomerates - OUT: list of affected indices
        Throws:
        StandardException - Thrown on error
      • remapReferencedColumns

        private int[] remapReferencedColumns​(ConstraintDescriptor cd,
                                             int[] rowMap)
        Remap referenced columns in the cd to reflect the passed in row map.
        Parameters:
        cd - constraint descriptor
        rowMap - 1 based row map
      • setRefActionInfo

        void setRefActionInfo​(long fkIndexConglomId,
                              int[] fkColArray,
                              java.lang.String parentResultSetId,
                              boolean dependentScan)
        Description copied from class: QueryTreeNode
        set the Information gathered from the parent table that is required to perform a referential action on dependent table.
        Overrides:
        setRefActionInfo in class QueryTreeNode
      • normalizeSynonymColumns

        void normalizeSynonymColumns​(ResultColumnList rcl,
                                     TableName targetTableName)
                              throws StandardException
        Normalize synonym column references to have the name of the base table.
        Parameters:
        rcl - The result column list of the target table
        targetTableName - The target tablename
        Throws:
        StandardException - Thrown on error
      • printSubNodes

        void printSubNodes​(int depth)
        Prints the sub-nodes of this object. See QueryTreeNode.java for how tree printing is supposed to work.
        Overrides:
        printSubNodes in class DMLStatementNode
        Parameters:
        depth - The depth of this node in the tree