Ejemplo n.º 1
0
  /**
   * @see org.apache.derby.iapi.sql.ResultSet#cleanUp
   * @exception StandardException Thrown on error
   */
  public void cleanUp() throws StandardException {
    if (rowHolder != null) {
      rowHolder.close();
    }

    if (rs != null) {
      try {
        rs.close();
      } catch (Throwable t) {
        throw StandardException.unexpectedUserException(t);
      }
      rs = null;
    }

    // Close the ps if it needs to be instantiated on each execution
    if (!vtiRS.isReuseablePs() && ps != null) {
      try {
        ps.close();
        ps = null;
      } catch (Throwable t) {
        throw StandardException.unexpectedUserException(t);
      }
    }
    super.cleanUp();
  } // end of cleanUp
Ejemplo n.º 2
0
  public void finish() throws StandardException {

    if ((ps != null) && !vtiRS.isReuseablePs()) {
      try {
        ps.close();
        ps = null;
      } catch (Throwable t) {
        throw StandardException.unexpectedUserException(t);
      }
    }
    super.finish();
  } // end of finish
  /**
   * Copy columns from srcrow into destrow, or insert ROW_NUMBER.
   *
   * <p><b>FIXME</b> This is temporary. Window function treatment needs to generalized to work for
   * other window functions.
   *
   * @exception StandardException thrown on failure to open
   */
  public void populateFromSourceRow(ExecRow srcrow, ExecRow destrow) throws StandardException {
    int srcindex = 1;

    try {
      DataValueDescriptor[] columns = destrow.getRowArray();
      for (int index = 0; index < columns.length; index++) {

        if (referencedColumns != null && !referencedColumns.get(index)) {
          columns[index].setValue((long) this.rownumber);
        } else {
          destrow.setColumn(index + 1, srcrow.getColumn(srcindex));
          srcindex++;
        }
      }
    } catch (StandardException se) {
      throw se;
    } catch (Throwable t) {
      throw StandardException.unexpectedUserException(t);
    }
  }
Ejemplo n.º 4
0
  private void insertIntoVTI(ResultSet target, ExecRow row) throws StandardException {
    try {
      target.moveToInsertRow();

      DataValueDescriptor[] rowArray = row.getRowArray();
      for (int index = 0; index < rowArray.length; index++) {
        DataValueDescriptor dvd = rowArray[index];

        try {
          if (dvd.isNull()) target.updateNull(index + 1);
          else dvd.setInto(target, index + 1);
        } catch (Throwable t) {
          // backwards compatibility - 5.0 and before used
          // updateObject always.
          target.updateObject(index + 1, dvd.getObject());
        }
      }

      target.insertRow();
    } catch (Throwable t) {
      throw StandardException.unexpectedUserException(t);
    }
  }
Ejemplo n.º 5
0
  /** @exception StandardException Standard Derby error policy */
  protected void openCore() throws StandardException {
    /* We must instantiate the VTI on each execution if any of the
     * parameters contain a ?.
     */
    if (ps == null) {
      ps = (PreparedStatement) vtiRS.getVTIConstructor().invoke(activation);
    }

    if (ps instanceof DeferModification) {
      try {
        ((DeferModification) ps)
            .modificationNotify(DeferModification.INSERT_STATEMENT, constants.deferred);
      } catch (Throwable t) {
        throw StandardException.unexpectedUserException(t);
      }
    }

    ExecRow row = getNextRowCore(sourceResultSet);

    try {
      rs = ps.executeQuery();
    } catch (Throwable t) {
      throw StandardException.unexpectedUserException(t);
    }

    /* Get or re-use the row changer.
     * NOTE: We need to set ourself as the top result set
     * if this is not the 1st execution.  (Done in constructor
     * for 1st execution.)
     */
    if (!firstExecute) {
      lcc.getStatementContext().setTopResultSet(this, subqueryTrackingArray);
    }

    /* 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 (firstExecute && constants.deferred) {
      Properties properties = new Properties();

      /*
       ** If deferred we save a copy of the entire row.
       */
      rowHolder = new TemporaryRowHolderImpl(activation, properties);
    }

    while (row != null) {
      /*
       ** 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 {
        insertIntoVTI(rs, row);
      }

      rowCount++;

      // No need to do a next on a single row source
      if (constants.singleRowSource) {
        row = null;
      } else {
        row = getNextRowCore(sourceResultSet);
      }
    }

    /*
     ** If it's a deferred insert, scan the temporary conglomerate and
     ** insert the rows into the permanent conglomerates using rowChanger.
     */
    if (constants.deferred) {
      CursorResultSet tempRS = rowHolder.getResultSet();
      try {
        tempRS.open();
        while ((row = tempRS.getNextRow()) != null) {
          insertIntoVTI(rs, row);
        }
      } finally {
        sourceResultSet.clearCurrentRow();
        tempRS.close();
      }
    }

    if (rowHolder != null) {
      rowHolder.close();
      // rowHolder kept across opens
    }
  } // end of normalInsertCore