Class InsertNode

  • All Implemented Interfaces:
    Visitable

    public final class InsertNode
    extends DMLModGeneratedColumnsStatementNode
    An InsertNode is the top node in a query tree for an insert statement.

    After parsing, the node contains targetTableName: the target table for the insert collist: a list of column names, if specified queryexpr: the expression being inserted, either a values clause or a select form; both of these are represented via the SelectNode, potentially with a TableOperatorNode such as UnionNode above it.

    After binding, the node has had the target table's descriptor located and inserted, and the queryexpr and collist have been massaged so that they are identical to the table layout. This involves adding any default values for missing columns, and reordering the columns to match the table's ordering of them.

    After optimizing, ...

    • Field Detail

      • deferred

        private boolean deferred
      • checkConstraints

        public ValueNode checkConstraints
      • hasDeferrableCheckConstraints

        public boolean hasDeferrableCheckConstraints
      • targetProperties

        public java.util.Properties targetProperties
      • fkInfo

        public FKInfo fkInfo
      • bulkInsert

        protected boolean bulkInsert
      • bulkInsertReplace

        private boolean bulkInsertReplace
      • hasJDBClimitClause

        private boolean hasJDBClimitClause
    • Constructor Detail

      • InsertNode

        InsertNode​(QueryTreeNode targetName,
                   ResultColumnList insertColumns,
                   ResultSetNode queryExpression,
                   MatchingClauseNode matchingClause,
                   java.util.Properties targetProperties,
                   OrderByList orderByList,
                   ValueNode offset,
                   ValueNode fetchFirst,
                   boolean hasJDBClimitClause,
                   ContextManager cm)
        Constructor for an InsertNode.
        Parameters:
        targetName - The name of the table/VTI to insert into
        insertColumns - A ResultColumnList with the names of the columns to insert into. May be null if the user did not specify the columns - in this case, the binding phase will have to figure it out.
        queryExpression - The query expression that will generate the rows to insert into the given table
        matchingClause - Non-null if this DML is part of a MATCHED clause of a MERGE statement.
        targetProperties - The properties specified on the target table
        orderByList - The order by list for the source result set, null if no order by list
        offset - The value of a if present
        fetchFirst - The value of a if present
        hasJDBClimitClause - True if the offset/fetchFirst clauses come from JDBC limit/offset escape syntax
        cm - The context manager
    • Method Detail

      • toString

        public java.lang.String toString()
        Convert this object to a String. See comments in QueryTreeNode.java for how this should be done for tree printing.
        Overrides:
        toString in class StatementNode
        Returns:
        This object as a String
      • 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 DMLModStatementNode
        Parameters:
        depth - The depth of this node in the tree
      • bindStatement

        public void bindStatement()
                           throws StandardException
        Bind this InsertNode. This means looking up tables and columns and getting their types, and figuring out the result types of all expressions, as well as doing view resolution, permissions checking, etc.

        Binding an insert will also massage the tree so that the collist and select column order/number are the same as the layout of the table in the store.

        Overrides:
        bindStatement in class StatementNode
        Throws:
        StandardException - Thrown on error
      • enhanceAndCheckForAutoincrement

        ResultSetNode enhanceAndCheckForAutoincrement​(ResultSetNode resultSet,
                                                      boolean inOrder,
                                                      int[] colMap,
                                                      boolean defaultsWereReplaced)
                                               throws StandardException
        Process ResultSet column lists for projection and autoincrement. This method recursively descends the result set node tree. When it finds a simple result set, it processes any autoincrement columns in that rs by calling checkAutoIncrement. When it finds a compound result set, like a Union or a PRN, it recursively descends to the child(ren) nodes. Union nodes can arise due to multi-rows in VALUES clause), PRN nodes can arise when the set of columns being inserted is a subset of the set of columns in the table. In addition to checking for autoincrement columns in the result set, we may need to enhance and re-order the column list to match the column list of the table we are inserting into. This work is handled by ResultsetNode.enhanceRCLForInsert. Note that, at the leaf level, we need to enhance the RCL first, then check for autoincrement columns. At the non-leaf levels, we have to enhance the RCL, but we don't have to check for autoincrement columns, since they only occur at the leaf level. This way, all ColumnDescriptor of all rows will be set properly.
        Parameters:
        resultSet - current node in the result set tree
        inOrder - FALSE if the column list needs reordering
        colMap - correspondence between RCLs
        defaultsWereReplaced - true if DEFAULT clauses were replaced with generated expressions
        Returns:
        a node representing the source for the insert
        Throws:
        StandardException - Thrown on error
      • getPrivType

        int getPrivType()
        Description copied from class: DMLStatementNode
        Return default privilege needed for this node. Other DML nodes can override this method to set their own default privilege.
        Overrides:
        getPrivType in class DMLStatementNode
        Returns:
        true if the statement is atomic
      • verifyTargetProperties

        private void verifyTargetProperties​(DataDictionary dd)
                                     throws StandardException
        Verify that the target properties that we are interested in all hold valid values. NOTE: Any target property which is valid but cannot be supported due to a target database, etc. will be turned off quietly.
        Parameters:
        dd - The DataDictionary
        Throws:
        StandardException - Thrown on error
      • verifyBulkInsert

        private boolean verifyBulkInsert​(DataDictionary dd,
                                         java.lang.String mode)
                                  throws StandardException
        Do the bind time checks to see if bulkInsert is allowed on this table. bulkInsert is disallowed at bind time for: o target databases o (tables with triggers?) (It is disallowed at execution time if the table has at least 1 row in it or if it is a deferred mode insert.)
        Parameters:
        dd - The DataDictionary
        mode - The insert mode
        Returns:
        Whether or not bulkInsert is allowed.
        Throws:
        StandardException - Thrown on error
      • getIndexedCols

        boolean[] getIndexedCols()
                          throws StandardException
        Create a boolean[] to track the (0-based) columns which are indexed.
        Returns:
        A boolean[] to track the (0-based) columns which are indexed.
        Throws:
        StandardException - Thrown on failure
      • 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.

        Remove any duplicate ORDER BY columns and push an ORDER BY if present down to the source result set, before calling super.optimizeStatement.

        Overrides:
        optimizeStatement in class DMLModStatementNode
        Throws:
        StandardException - Thrown on failure
      • requestBulkInsert

        private void requestBulkInsert()
        Request bulk insert optimization at run time.
      • generate

        void generate​(ActivationClassBuilder acb,
                      MethodBuilder mb)
               throws StandardException
        Code generation for insert creates an expression for: ResultSetFactory.getInsertResultSet(resultSet.generate(ps), generationClausesResult, checkConstrainResult, this )
        Overrides:
        generate in class QueryTreeNode
        Parameters:
        acb - The ActivationClassBuilder for the class being built
        mb - the method for the execute() method to be built
        Throws:
        StandardException - Thrown on error
      • getStatementType

        protected final int getStatementType()
        Return the type of statement, something from StatementType.
        Overrides:
        getStatementType in class QueryTreeNode
        Returns:
        the type of statement
      • getStatementType

        static int getStatementType​(java.util.Properties targetProperties)
        Return the statement type, where it is dependent on the targetProperties. (insertMode = replace causes statement type to be BULK_INSERT_REPLACE.
        Returns:
        the type of statement
      • getAffectedIndexes

        private void getAffectedIndexes​(TableDescriptor td)
                                 throws StandardException
        Get the list of indexes on the table being inserted into. This is used by INSERT. This is an optimized version of what UPDATE and DELETE use.
        Parameters:
        td - TableDescriptor for the table being inserted into or deleted from
        Throws:
        StandardException - Thrown on error