Derby - Class org.apache.derby.impl.sql.execute.InsertResultSet

   Licensed to the Apache Software Foundation (ASF) under one or more

   contributor license agreements.  See the NOTICE file distributed with

   this work for additional information regarding copyright ownership.

   The ASF licenses this file to you under the Apache License, Version 2.0

   (the "License"); you may not use this file except in compliance with

   the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software

   distributed under the License is distributed on an "AS IS" BASIS,

   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   See the License for the specific language governing permissions and

   limitations under the License.

*/

* Insert the rows from the source into the specified

* base table. This will cause constraints to be checked

* and triggers to be executed based on the c's and t's

* compiled into the insert plan.

*/

  // RESOLVE. Embarassingly large public state. If we could move the Replication

  // code into the same package, then these variables could be protected.

  // passed in at construction time

                                                

  private  NoPutResultSet      sourceResultSet;

  NoPutResultSet      savedSource;

  InsertConstantAction  constants;

    private GeneratedMethod         generationClauses;

  private GeneratedMethod      checkGM;

  private long          heapConglom;

  //following is for jdbc3.0 feature auto generated keys resultset

  private  ResultSet      autoGeneratedKeysResultSet;

  private  TemporaryRowHolderImpl  autoGeneratedKeysRowsHolder;

  // divined at run time

  private RowChanger         rowChanger;

  private  TransactionController   tc;

  private  ExecRow          row;

 

  boolean          userSpecifiedBulkInsert;

  boolean          bulkInsertPerformed;

  // bulkInsert

  protected boolean        bulkInsert;

  private boolean          bulkInsertReplace;

  private boolean          firstRow = true;

  private  boolean[]        needToDropSort;

  /*

  ** This hashtable is used to convert an index conglomerate

  ** from it's old conglom number to the new one.  It is

  ** bulk insert specific.

  */

  private Hashtable        indexConversionTable;

  // indexedCols is 1-based

  private FormatableBitSet          indexedCols;

  private ConglomerateController  bulkHeapCC;

  protected DataDictionary      dd;

  protected TableDescriptor      td;

   

  private ExecIndexRow[]      indexRows;

  private ExecRow          fullTemplate;

  private  long[]          sortIds;

  private RowLocationRetRowSource[]

                                    rowSources;

  private  ScanController      bulkHeapSC;

  private ColumnOrdering[][]    ordering;

  private int[][]                collation;

  private SortController[]    sorters;

  private  TemporaryRowHolderImpl  rowHolder;

  private RowLocation        rl;

  private  boolean          hasBeforeStatementTrigger;

  private  boolean          hasBeforeRowTrigger;

  private  BulkTableScanResultSet  tableScan;

  private int            numOpens;

  private boolean          firstExecute;

  // cached across open()s

  private  FKInfo[]        fkInfoArray;

  private  TriggerInfo        triggerInfo;

  private RISetChecker       fkChecker;

  private TriggerEventActivator  triggerActivator;

  /**

   * keeps track of autoincrement values that are generated by

   * getSetAutoincrementValues.

   */

  private NumberDataValue        aiCache[];

  /**

   * If set to true, implies that this (rep)insertresultset has generated

   * autoincrement values. During refresh for example, the autoincrement

   * values are not generated but sent from the source to target or

   * vice-versa.

   */

  protected boolean         autoincrementGenerated;

  private long          identityVal;  //support of IDENTITY_LOCAL_VAL function

  private boolean          setIdentity;

 

  // TargetResultSet interface

  /**

   * @see TargetResultSet#changedRow

   *

   * @exception StandardException thrown if cursor finish ed.

   */

  public void changedRow(ExecRow execRow, RowLocation rowLocation)

    throws StandardException

  {

    if (SanityManager.DEBUG)

    {

      SanityManager.ASSERT(bulkInsert,

        "bulkInsert exected to be true");

    }

    /* Set up sorters, etc. if 1st row and there are indexes */

    if (constants.irgs.length > 0)

    {

           RowLocation rlClone = (RowLocation) rowLocation.cloneValue(false);

      // Objectify any the streaming columns that are indexed.

      for (int i = 0; i < execRow.getRowArray().length; i++)

      {

        if (! constants.indexedCols[i])

        {

          continue;

        }

        if (execRow.getRowArray()[i] instanceof StreamStorable)

          ((DataValueDescriptor)execRow.getRowArray()[i]).getObject();

      }

      // Every index row will share the same row location, etc.

      if (firstRow)

      {

        firstRow = false;

        indexRows = new ExecIndexRow[constants.irgs.length];

        setUpAllSorts(execRow.getNewNullRow(), rlClone);

      }

      // Put the row into the indexes

      for (int index = 0; index < constants.irgs.length; index++)

      {

        // Get a new object Array for the index

        indexRows[index].getNewObjectArray();

        // Associate the index row with the source row

        constants.irgs[index].getIndexRow(execRow,

                         rlClone,

                         indexRows[index],

                         (FormatableBitSet) null);

        // Insert the index row into the matching sorter

        sorters[index].insert(indexRows[index].getRowArray());

      }

    }

  }

  /**

   * Preprocess the source row.  Apply any check constraints here.

   * Do an inplace cloning of all key columns.  For triggers, if

   * we have a before row trigger, we fire it here if we can.

   * This is useful for bulk insert where the store stands between

   * the source and us.

   *

   * @param execRow  The source row.

   *

   * @return The preprocessed source row.

   * @exception StandardException thrown on error

   */

  public ExecRow preprocessSourceRow(ExecRow execRow)

    throws StandardException

  {

    //System.out.println("preprocessrow is called ");

    /*

    ** We can process before row triggers now.  All other

    ** triggers can only be fired after we have inserted

    ** all our rows.

    */

    if (hasBeforeRowTrigger)

    {

      // RESOLVE

      // Possibly dead code-- if there are triggers we don't do bulk insert.

      rowHolder.truncate();

      rowHolder.insert(execRow);

      triggerActivator.notifyEvent(TriggerEvents.BEFORE_INSERT,

                      (CursorResultSet)null,

                      rowHolder.getResultSet());

    }

        if ( generationClauses != null )

        {

            evaluateGenerationClauses( generationClauses, activation, sourceResultSet, execRow, false );

        }

    if (checkGM != null && !hasBeforeStatementTrigger)

    {

      evaluateCheckConstraints();

    }

    // RESOLVE - optimize the cloning

    if (constants.irgs.length > 0)

    {

      /* Do in-place cloning of all of the key columns */

      return execRow.getClone(indexedCols);

    }

    else

    {

      return execRow;

    }

  }

  /**

    *  Run the check constraints against the current row. Raise an error if

    * a check constraint is violated.

    *

    * @exception StandardException thrown on error

    */

  private  void  evaluateCheckConstraints()

    throws StandardException

  {

    if (checkGM != null)

    {

      // Evaluate the check constraints. The expression evaluation

      // will throw an exception if there is a violation, so there

      // is no need to check the result of the expression.

      checkGM.invoke(activation);

    }

  }

    /*

     * class interface

     *

     */

    /**

   *

   * @exception StandardException    Thrown on error

     */

    InsertResultSet(NoPutResultSet source,

               GeneratedMethod generationClauses,

               GeneratedMethod checkGM,

               Activation activation)

    throws StandardException

    {

    super(activation);

    sourceResultSet = source;

    constants = (InsertConstantAction) constantAction;

        this.generationClauses = generationClauses;

    this.checkGM = checkGM;

    heapConglom = constants.conglomId;

        tc = activation.getTransactionController();

    fkInfoArray = constants.getFKInfo();

    triggerInfo = constants.getTriggerInfo();

   

    /*

    ** If we have a before statement trigger, then

    ** we cannot check constraints inline.

    */

    hasBeforeStatementTrigger = (triggerInfo != null) ?

        triggerInfo.hasTrigger(true, false) :

        false;

    hasBeforeRowTrigger = (triggerInfo != null) ?

        triggerInfo.hasTrigger(true, true) :

        false;

        ResultDescription resultDescription = activation.getResultDescription();

    // Is this a bulkInsert or regular insert?

    String insertMode = constants.getProperty("insertMode");

                RowLocation[] rla;

    if ((rla = constants.getAutoincRowLocation()) != null)

    {

      aiCache =

        new NumberDataValue[rla.length];

      for (int i = 0; i < resultDescription.getColumnCount(); i++)

      {

        if (rla[i] == null)

          continue;

        ResultColumnDescriptor rcd =

          resultDescription.getColumnDescriptor(i + 1);

        aiCache[i] = (NumberDataValue)rcd.getType().getNull();

      }

    }

    if (insertMode != null)

    {

      if (StringUtil.SQLEqualsIgnoreCase(insertMode,"BULKINSERT"))

      {

        userSpecifiedBulkInsert = true;

      }

      else if (StringUtil.SQLEqualsIgnoreCase(insertMode,"REPLACE"))

      {

        userSpecifiedBulkInsert = true;

        bulkInsertReplace = true;

        bulkInsert = true;

        /*

        ** For now, we don't allow bulk insert replace when

        ** there is a trigger.

        */

        if (triggerInfo != null)

        {

          TriggerDescriptor td = triggerInfo.getTriggerArray()[0];

          throw StandardException.newException(SQLState.LANG_NO_BULK_INSERT_REPLACE_WITH_TRIGGER_DURING_EXECUTION, constants.getTableName(), td.getName());

        }

      }

    }

    //System.out.println("new InsertResultSet " + sourceResultSet.getClass());

  }

 

  /**

    @exception StandardException Standard Derby error policy

  */

  public void open() throws StandardException

  {

    setup();

    // Remember if this is the 1st execution

    firstExecute = (rowChanger == null);

    autoincrementGenerated = false;

    dd = lcc.getDataDictionary();

    /*

    ** verify the auto-generated key columns list(ie there are no invalid column

    ** names or positions). This is done at at execution time because for a precompiled

    ** insert statement, user can specify different column selections for

    ** auto-generated keys.

    */

    if(activation.getAutoGeneratedKeysResultsetMode())

    {

      if (activation.getAutoGeneratedKeysColumnIndexes() != null)

        verifyAutoGeneratedColumnsIndexes(activation.getAutoGeneratedKeysColumnIndexes());

      else  if (activation.getAutoGeneratedKeysColumnNames() != null)

        verifyAutoGeneratedColumnsNames(activation.getAutoGeneratedKeysColumnNames());

    }

    rowCount = 0;

    if (numOpens++ == 0)

    {

      sourceResultSet.openCore();

    }

    else

    {

      sourceResultSet.reopenCore();

    }

    /* If the user specified bulkInsert (or replace) then we need

     * to get an exclusive table lock on the table.  If it is a

     * regular bulk insert then we need to check to see if the

     * table is empty.  (If not empty, then we end up doing a row

     * at a time insert.)

     */

    if (userSpecifiedBulkInsert)

    {

      if (! bulkInsertReplace)

      {

        bulkInsert = verifyBulkInsert();

      }

      else

      {

        getExclusiveTableLock();

      }

    }

    if (bulkInsert)

    {

      // Notify the source that we are the target

      sourceResultSet.setTargetResultSet(this);

      long baseTableConglom = bulkInsertCore(lcc, heapConglom);

      if (hasBeforeStatementTrigger)

      { 

        tableScan = getTableScanResultSet(baseTableConglom);

        // fire BEFORE trigger, do this before checking constraints

        triggerActivator.notifyEvent(TriggerEvents.BEFORE_INSERT,

                        (CursorResultSet)null,

                        tableScan);

     

        // if we have a check constraint or generation clauses, we have

        // to do it the hard way now before we get

        // to our AFTER triggers.

        if ((checkGM != null) || (generationClauses != null) )

        {

          tableScan = getTableScanResultSet(baseTableConglom);

          try

          {

            ExecRow currRow = null;

            while ((currRow = tableScan.getNextRowCore()) != null)

            {

              // we have to set the source row so the check constraint

              // sees the correct row.

              sourceResultSet.setCurrentRow(currRow);

               evaluateCheckConstraints();

            }

          } finally

          {

            sourceResultSet.clearCurrentRow();

          }

        }

      }

     

      bulkValidateForeignKeys(tc, lcc.getContextManager());

 

      // if we have an AFTER trigger, let 'er rip

      if ((triggerInfo != null) &&

        (triggerInfo.hasTrigger(false, true) ||

         triggerInfo.hasTrigger(false, false)))

      {

        triggerActivator.notifyEvent(TriggerEvents.AFTER_INSERT,

                    (CursorResultSet)null,

                    getTableScanResultSet(baseTableConglom));

      }

      bulkInsertPerformed = true;

    }

    else

    {

          row = getNextRowCore(sourceResultSet);

      normalInsertCore(lcc, firstExecute);

    }

    /* Cache query plan text for source, before it gets blown away */

    if (lcc.getRunTimeStatisticsMode())

    {

      /* savedSource nulled after run time statistics generation */

      savedSource = sourceResultSet;

    }

    /* autoGeneratedResultset for JDBC3. Nulled after statement execution is over

    (ie after it is saved off in LocalSatement object) */

    if (activation.getAutoGeneratedKeysResultsetMode())

      autoGeneratedKeysResultSet = autoGeneratedKeysRowsHolder.getResultSet();

    else

      autoGeneratedKeysResultSet = null;

    cleanUp();

    if (aiCache != null)

    {

      HashMap aiHashtable = new HashMap();

      int numColumns = aiCache.length;

      // this insert updated ai values, store them in some persistent

      // place so that I can see these values.

      for (int i = 0; i < numColumns; i++)

      {

        if (aiCache[i] == null)

          continue;

        aiHashtable.put(AutoincrementCounter.makeIdentity(

                  constants.getSchemaName(),

                  constants.getTableName(),

                  constants.getColumnName(i)),

                new Long(aiCache[i].getLong()));

      }

      InternalTriggerExecutionContext itec =

        (InternalTriggerExecutionContext)lcc.getTriggerExecutionContext();

      if (itec == null)

        lcc.copyHashtableToAIHT(aiHashtable);

      else

        itec.copyHashtableToAIHT(aiHashtable);

    } 

    endTime = getCurrentTimeMillis();

  }

  /**

   * Clean up resources and call close on data members.

   */

  public void close() throws StandardException {

    super.close();

    if (autoGeneratedKeysRowsHolder != null) {

      autoGeneratedKeysRowsHolder.close();

    }

  }

  /**

   * Verify that the auto-generated columns list (by position) has valid

   * column positions for the table.

   */

  private void verifyAutoGeneratedColumnsIndexes(int[] columnIndexes)

    throws StandardException

  {

    int size = columnIndexes.length;

    TableDescriptor td = dd.getTableDescriptor(constants.targetUUID);

    // all 1-based column ids.

    for (int i = 0; i < size; i++)

    {

      ColumnDescriptor cd = td.getColumnDescriptor(columnIndexes[i]);

      if (!verifyAutoGenColumn(cd))

      {

        throw StandardException.newException(

          SQLState.LANG_INVALID_AUTOGEN_COLUMN_POSITION,

          new Integer(columnIndexes[i]), td.getName());

      }

    }

  }

  /**

   * If user didn't provide columns list for auto-generated columns, then only include

   * columns with auto-generated values in the resultset. Those columns would be ones

   * with default value defined.

   */

  private int[] generatedColumnPositionsArray()

    throws StandardException

  {

    TableDescriptor td = dd.getTableDescriptor(constants.targetUUID);

    ColumnDescriptor cd;

    int size = td.getMaxColumnID();

    int[] generatedColumnPositionsArray = new int[size];

    int generatedColumnNumbers = 0;

    for (int i=0; i<size; i++) {

      generatedColumnPositionsArray[i] = -1;

    }

    for (int i=0; i<size; i++) {

      cd = td.getColumnDescriptor(i+1);

      if (cd.isAutoincrement()) { //if the column has auto-increment value

        generatedColumnNumbers++;

        generatedColumnPositionsArray[i] = i+1;

      } else if (cd.getDefaultValue() != null || cd.getDefaultInfo() != null) {//default value

        generatedColumnNumbers++;

        generatedColumnPositionsArray[i] = i+1;

      }

    }

    int[] returnGeneratedColumnPositionsArray = new int[generatedColumnNumbers];

    for (int i=0, j=0; i<size; i++) {

      if (generatedColumnPositionsArray[i] != -1)

        returnGeneratedColumnPositionsArray[j++] = generatedColumnPositionsArray[i];

    }

    return returnGeneratedColumnPositionsArray;

  }

  /**

   * Remove duplicate columns from the array. Then use this array to generate a sub-set

   * of insert resultset to be returned for JDBC3.0 getGeneratedKeys() call.

   */

  private int[] uniqueColumnPositionArray(int[] columnIndexes)

    throws StandardException

  {

    int size = columnIndexes.length;

    TableDescriptor td = dd.getTableDescriptor(constants.targetUUID);

    //create an array of integer (the array size = number of columns in table)

    // valid column positions are 1...getMaxColumnID()

    int[] uniqueColumnIndexes = new int[td.getMaxColumnID()];

    int uniqueColumnNumbers = 0;

    //At the end of following loop, the uniqueColumnIndexes elements will not be 0 for user

    //selected auto-generated columns.

    for (int i=0; i<size; i++) {

      if (uniqueColumnIndexes[columnIndexes[i] - 1] == 0) {

        uniqueColumnNumbers++;

        uniqueColumnIndexes[columnIndexes[i] - 1] = columnIndexes[i];

      }

    }

    int[] returnUniqueColumnIndexes = new int[uniqueColumnNumbers];

    //return just the column positions which are not marked 0 in the uniqueColumnIndexes array

    for (int i=0, j=0; i<uniqueColumnIndexes.length; i++) {

      if (uniqueColumnIndexes[i] != 0)

        returnUniqueColumnIndexes[j++] = uniqueColumnIndexes[i];

    }

    return returnUniqueColumnIndexes;

  }

  /**

   * Verify that the auto-generated columns list (by name) has valid

   * column names for the table. If all the column names are valid,

   * convert column names array to corresponding column positions array

   * Save that column positions array in activation. We do this to simplify the

   * rest of the logic(it only has to deal with column positions here after).

   *

   * @exception StandardException    Thrown on error if invalid column

   * name in the list.

   */

  private void verifyAutoGeneratedColumnsNames(String[] columnNames)

    throws StandardException

  {

    int size = columnNames.length;

    int columnPositions[] = new int[size];

     TableDescriptor td = dd.getTableDescriptor(constants.targetUUID);

    ColumnDescriptor cd;

    for (int i = 0; i < size; i++)

    {

      if (columnNames[i] == null)

      {

        throw StandardException.newException(

          SQLState.LANG_INVALID_AUTOGEN_COLUMN_NAME,

          columnNames[i], td.getName());

      }

      cd = td.getColumnDescriptor(columnNames[i]);

      if (!verifyAutoGenColumn(cd))

      {

        throw StandardException.newException(

          SQLState.LANG_INVALID_AUTOGEN_COLUMN_NAME,

          columnNames[i], td.getName());

      }

      columnPositions[i] = cd.getPosition();

    }

    activation.setAutoGeneratedKeysResultsetInfo(columnPositions, null);

  }

  /**

   * Check that the received ColumnDescriptor corresponds to a column

   * for which it is possible to fetch auto-generated keys.

   */

  private boolean verifyAutoGenColumn(ColumnDescriptor cd)

  {

    /* Derby currently gets generated keys by calling the

     * IDENTITY_VAL_LOCAL() function (see "getGeneratedKeys()"

     * as defined on EmbedStatement).  That function only

     * considers autoincrement columns.  So if the column

     * specified by the user is not autoincrement, we return

     * false.

     */

    return ((cd != null) && cd.isAutoincrement());

  }

  /**

   * @see ResultSet#getAutoGeneratedKeysResultset

   */

  public ResultSet getAutoGeneratedKeysResultset()

  {

    return autoGeneratedKeysResultSet;

  }

  /**

   * getSetAutoincrementValue will get the autoincrement value of the

   * columnPosition specified for the target table. If increment is

   * non-zero we will also update the autoincrement value.

   *

   * @param columnPosition  position of the column in the table (1-based)

   * @param increment      amount of increment.

   *

   * @exception StandardException if anything goes wrong.

   */

  public NumberDataValue

    getSetAutoincrementValue(int columnPosition, long increment)

    throws StandardException

  {

    long startValue = 0;

                NumberDataValue dvd;

    int index = columnPosition - 1;  // all our indices are 0 based.

    /* As in DB2, only for single row insert: insert into t1(c1) values (..) do

     * we return the correct most recently generated identity column value.  For

     * multiple row insert, or insert with sub-select, the return value is non-

     * deterministic, and is the previous return value of the IDENTITY_VAL_LOCAL

     * function, before the insert statement.  Also, DB2 can have at most 1 identity

     * column per table.  The return value won't be affected either if Derby

     * table has more than one identity columns.

     */

    setIdentity = (! autoincrementGenerated) && isSourceRowResultSet();

    autoincrementGenerated = true;

      if (bulkInsert)

      {

      ColumnDescriptor cd = td.getColumnDescriptor(columnPosition);

      long ret;

      // for bulk insert we have the table descriptor

      //      System.out.println("in bulk insert");

      if (aiCache[index].isNull())

      {

        if (bulkInsertReplace)

        {

          startValue = cd.getAutoincStart();

        }

        else

        {

          dvd = dd.getSetAutoincrementValue(

                constants.autoincRowLocation[index],

              tc, false, aiCache[index], true);

          startValue = dvd.getLong();

        }

        lcc.autoincrementCreateCounter(td.getSchemaName(),

                         td.getName(),

                         cd.getColumnName(),

                         new Long(startValue),

                         increment,

                         columnPosition);

     

      }     

      ret = lcc.nextAutoincrementValue(td.getSchemaName(),

                       td.getName(),

                       cd.getColumnName());

      aiCache[columnPosition - 1].setValue(ret);

    } 

    else

    {

      NumberDataValue newValue;

      TransactionController nestedTC = null, tcToUse = tc;

      try

      {

        nestedTC = tc.startNestedUserTransaction(false);

        tcToUse = nestedTC;

      }

      catch (StandardException se)

      {

        // If I cannot start a Nested User Transaction use the parent

        // transaction to do all the work.

        tcToUse = tc;

      }

      try

      {

        /* If tcToUse == tc, then we are using parent xaction-- this

           can happen if for some reason we couldn't start a nested

           transaction

        */

        newValue = dd.getSetAutoincrementValue(

               constants.autoincRowLocation[index],

               tcToUse, true, aiCache[index], (tcToUse == tc));

      }

      catch (StandardException se)

      {

        if (tcToUse == tc)

        {

          /* we've using the parent xaction and we've timed out; just

             throw an error and exit.

          */

          throw se;

        }

        if (se.getMessageId().equals(SQLState.LOCK_TIMEOUT))

        {

          // if we couldn't do this with a nested xaction, retry with

          // parent-- we need to wait this time!

          newValue = dd.getSetAutoincrementValue(

                  constants.autoincRowLocation[index],

                  tc, true, aiCache[index], true);

        }

        else if (se.getMessageId().equals(SQLState.LANG_OUTSIDE_RANGE_FOR_DATATYPE))

        {

          // if we got an overflow error, throw a more meaningful

          // error message

          throw StandardException.newException(

                         SQLState.LANG_AI_OVERFLOW,

                         se,

                         constants.getTableName(),

                         constants.getColumnName(index));

        }

        else throw se;

      }

      finally

      {

        // no matter what, commit the nested transaction; if something

        // bad happened in the child xaction lets not abort the parent

        // here.

        if (nestedTC != null)

        {

          nestedTC.commit();

          nestedTC.destroy();

        }

      }

      aiCache[index] = newValue;

      if (setIdentity)

        identityVal = newValue.getLong();

    }

    return aiCache[index];

   

  }

  // Is sourceResultSet a RowResultSet (values clause)?

  private boolean isSourceRowResultSet ()

  {

    boolean isRow = false;

    if (sourceResultSet instanceof NormalizeResultSet)

      isRow = (((NormalizeResultSet) sourceResultSet).source instanceof RowResultSet);

    return isRow;

  }

    // checks if source result set is a RowResultSet type.

    private boolean isSingleRowResultSet()

    {

        boolean isRow = false;

       

        if (sourceResultSet instanceof RowResultSet)

          isRow = true;

        else if (sourceResultSet instanceof NormalizeResultSet)

            isRow = (((NormalizeResultSet) sourceResultSet).source instanceof RowResultSet);

       

        return isRow;

    }

 

  // Do the work for a "normal" insert

  private void normalInsertCore(LanguageConnectionContext lcc, boolean firstExecute)

    throws StandardException

  {

    boolean setUserIdentity = constants.hasAutoincrement() && isSingleRowResultSet();

    boolean  firstDeferredRow = true;

    ExecRow  deferredRowBuffer = null;

                long user_autoinc=0;

                       

    /* Get or re-use the row changer.

     */

    if (firstExecute)

    {

      rowChanger = lcc.getLanguageConnectionFactory().getExecutionFactory()

                 .getRowChanger(

                   heapConglom,

                   constants.heapSCOCI,

                   heapDCOCI,

                   constants.irgs,

                   constants.indexCIDS,

                   constants.indexSCOCIs,

                   indexDCOCIs,

                   0, // number of columns in partial row meaningless for insert

                   tc,

                   null, //Changed column ids

                   constants.getStreamStorableHeapColIds(),

                   activation

                     );

      rowChanger.setIndexNames(constants.indexNames);

    }

    /* decode lock mode for the execution isolation level */

    int lockMode = decodeLockMode(constants.lockMode);

    rowChanger.open(lockMode);

    /* The source does not know whether or not we are doing a

     * deferred mode insert.  If we are, then we must clear the

     * index scan info from the activation so that the row changer

     * does not re-use that information (which won't be valid for

     * a deferred mode insert).

     */

    if (constants.deferred)

    {

      activation.clearIndexScanInfo();

    }

    if (fkInfoArray != null)

    {

      if (fkChecker == null)

      {

        fkChecker = new RISetChecker(tc, fkInfoArray);

      }

      else

      {

        fkChecker.reopen();

      }

    }

    if (firstExecute && constants.deferred)

    {

      Properties properties = new Properties();

      // Get the properties on the old heap

      rowChanger.getHeapConglomerateController().getInternalTablePropertySet(properties);

      /*

      ** If deferred we save a copy of the entire row.

      */

      rowHolder = new TemporaryRowHolderImpl(activation, properties);

      rowChanger.setRowHolder(rowHolder);

    }

    int[] columnIndexes = null;

    if (firstExecute && activation.getAutoGeneratedKeysResultsetMode())

    {

      Properties properties = new Properties();

      columnIndexes = activation.getAutoGeneratedKeysColumnIndexes();

      // Get the properties on the old heap

      rowChanger.getHeapConglomerateController().getInternalTablePropertySet(properties);

      if ( columnIndexes != null) {//use user provided column positions array

        columnIndexes = uniqueColumnPositionArray(columnIndexes);

      } else { //prepare array of auto-generated keys for the table since user didn't provide any

        columnIndexes = generatedColumnPositionsArray();

      }

      autoGeneratedKeysRowsHolder =

        new TemporaryRowHolderImpl(activation, properties);

    }

    while ( row != null )

    {

      if (activation.getAutoGeneratedKeysResultsetMode())

        autoGeneratedKeysRowsHolder.insert(getCompactRow(row, columnIndexes));

            // fill in columns that are computed from expressions on other columns

            evaluateGenerationClauses( generationClauses, activation, sourceResultSet, row, false );

                   

      /*

      ** If we're doing a deferred insert, insert into the temporary

      ** conglomerate.  Otherwise, insert directly into the permanent

      ** conglomerates using the rowChanger.

      */

      if (constants.deferred)

      {

          rowHolder.insert(row);

      }

      else

      {

        // Evaluate any check constraints on the row

        evaluateCheckConstraints();

        if (fkChecker != null)