java.sql.ResultSet#TYPE_FORWARD_ONLY源码实例Demo

@Override protected Statement newInstance() throws Exception {
  UnregisteredDriver driver = new TestDriver();
  AvaticaConnection connection = new AvaticaConnection(driver, driver.createFactory(),
      "jdbc:avatica", new Properties()) {
  };
  StatementHandle handle = mock(StatementHandle.class);
  AvaticaStatement statement = new AvaticaStatement(connection, handle,
      ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
      ResultSet.HOLD_CURSORS_OVER_COMMIT) {
  };
  statement.close();
  assertTrue("Statement is not closed", statement.isClosed());

  return statement;
}
 

@Override
public boolean supportsResultSetConcurrency(int type, int concurrency)
        throws SQLException
{
    return (type == ResultSet.TYPE_FORWARD_ONLY) &&
            (concurrency == ResultSet.CONCUR_READ_ONLY);
}
 

@Override
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
    if (resultSetType != ResultSet.TYPE_FORWARD_ONLY || resultSetConcurrency != ResultSet.CONCUR_READ_ONLY) {
        throw new SQLFeatureNotSupportedException();
    }
    return createStatement();
}
 

private void skipRows(ResultSet rs, RowBounds rowBounds) throws SQLException {
  if (rs.getType() != ResultSet.TYPE_FORWARD_ONLY) {
    if (rowBounds.getOffset() != RowBounds.NO_ROW_OFFSET) {
      rs.absolute(rowBounds.getOffset());
    }
  } else {
    for (int i = 0; i < rowBounds.getOffset(); i++) {
      rs.next();
    }
  }
}
 

@DataProvider(name = "rowSetScrollTypes")
protected Object[][] rowSetScrollTypes() throws Exception {
    RowSet rs = newInstance();

    return new Object[][]{
        {rs, ResultSet.TYPE_FORWARD_ONLY},
        {rs, ResultSet.TYPE_SCROLL_INSENSITIVE},
        {rs, ResultSet.TYPE_SCROLL_SENSITIVE}
    };
}
 

@DataProvider(name = "rowSetScrollTypes")
protected Object[][] rowSetScrollTypes() throws Exception {
    RowSet rs = newInstance();

    return new Object[][]{
        {rs, ResultSet.TYPE_FORWARD_ONLY},
        {rs, ResultSet.TYPE_SCROLL_INSENSITIVE},
        {rs, ResultSet.TYPE_SCROLL_SENSITIVE}
    };
}
 

public static int getJdbcResultSetType(byte thriftType) {
  switch (thriftType) {
    case gfxdConstants.RESULTSET_TYPE_FORWARD_ONLY:
      return ResultSet.TYPE_FORWARD_ONLY;
    case gfxdConstants.RESULTSET_TYPE_INSENSITIVE:
      return ResultSet.TYPE_SCROLL_INSENSITIVE;
    case gfxdConstants.RESULTSET_TYPE_SENSITIVE:
      return ResultSet.TYPE_SCROLL_SENSITIVE;
    default:
      throw new IllegalArgumentException("Thrift ResultSet type="
          + thriftType);
  }
}
 

/**
 * iBatis会用到这个方法
 */
public int getType() throws SQLException {
    return ResultSet.TYPE_FORWARD_ONLY;
}
 

CassandraPreparedStatement(CassandraConnection con, String cql) throws SQLException
{    	
    this(con, cql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
}
 

@Override
public int getResultSetType() throws SQLException {
    return ResultSet.TYPE_FORWARD_ONLY;
}
 

/** 
 * is this a scrollable cursor?
 * return true if this is not a forward only cursor
 */
protected boolean isScrollable()
{
	return (getScrollType() != ResultSet.TYPE_FORWARD_ONLY);
}
 

public StatementOption(final boolean returnGeneratedKeys) {
    this(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT, returnGeneratedKeys);
}
 

/**
 * See if a VTI modification statement should be deferred.
 *
 * @param statementType DeferModification.INSERT_STATEMENT, UPDATE_STATEMENT, or DELETE_STATEMENT
 * @param targetVTI The target VTI
 * @param updateColumnNames The list of columns being updated, null if this is not an update statement
 * @param source
 */
public static boolean deferIt( int statementType,
                               FromVTI targetVTI,
                               String[] updateColumnNames,
                               QueryTreeNode source)
    throws StandardException
{
    try
    {
        DeferModification deferralControl;
        int resultSetType = targetVTI.getResultSetType( );

        /* Deferred updates and deletes are implemented by scrolling the result set. So, if
         * the statement is an update or delete but the result set is not scrollable then do
         * not attempt to defer the statement.
         */
        if( (statementType == DeferModification.UPDATE_STATEMENT ||statementType == DeferModification.DELETE_STATEMENT)
            && resultSetType == ResultSet.TYPE_FORWARD_ONLY)
            return false;

        deferralControl = targetVTI.getDeferralControl();
        if( deferralControl == null)
        {
            String VTIClassName = targetVTI.getMethodCall().getJavaClassName();
            deferralControl = new DefaultVTIModDeferPolicy( VTIClassName,
                                                            ResultSet.TYPE_SCROLL_SENSITIVE == resultSetType);
        }
        if( deferralControl.alwaysDefer( statementType))
            return true;

        if( source == null && statementType != DeferModification.UPDATE_STATEMENT)
            return false;

        VTIDeferModPolicy deferralSearch = new VTIDeferModPolicy( targetVTI,
                                                                  updateColumnNames,
                                                                  deferralControl,
                                                                  statementType);

        if( source != null)
            source.accept( deferralSearch);

        if( statementType == DeferModification.UPDATE_STATEMENT)
        {
            // Apply the columnRequiresDefer method to updated columns not in the where clause.
            Enumeration columns = deferralSearch.columns.keys();
            while( columns.hasMoreElements())
            {
                if( deferralControl.columnRequiresDefer( statementType,
                                                         (String) columns.nextElement(),
                                                         false))
                    return true;
            }
        }
        return deferralSearch.deferred;
    }
    catch( SQLException sqle)
    {
        throw StandardException.unexpectedUserException(sqle);
    }
}
 

/**
 * This method resets the state of this DRDAResultset object so that it can
 * be re-used. This method should reset all variables of this class.
 * 
 */
protected void reset() {
	explicitlyClosed = false;
	state = NOT_OPENED;
	hasdata = true;
	rsLens = null;
	rsDRDATypes = null;
	rsPrecision = null;
	rsScale = null;
	
	outovr_drdaType = null;
	
	withHoldCursor = 0;	
	scrollType = ResultSet.TYPE_FORWARD_ONLY;
	concurType = 0;
	rowCount = 0;
	rs = null;
	
	blksize = 0;
	maxblkext = 0;	
	outovropt = 0;
	qryclsimp = CodePoint.QRYCLSIMP_NO;	
	qryrelscr = false;
	qryrownbr = 0;
	qryrfrtbl = false;	
	qryscrorn = 0;
	qryrowsns = false; 
	qryblkrst = false;
	qryrtndta = false;	
	qryrowset = 0;
	qryprctyp = 0;
	gotPrctyp = false; 	
	rtnextdta = 0;	
	nbrrow = 0;
	rslsetflg = null;	

	extDtaObjects = null;
	rsExtPositions = null;
	pkgcnstkn = null;
	splitQRYDTA = null;	
}
 

@Override
public int getType() throws SQLException {
    return ResultSet.TYPE_FORWARD_ONLY;
}
 

@Override
public int getType() {
    return ResultSet.TYPE_FORWARD_ONLY;
}
 

@Override
public int getResultSetType() throws SQLException {
    return ResultSet.TYPE_FORWARD_ONLY;
}
 

/**
    * JDBC 2.0
    *
    * Does the database support the given result set type?
    *
    * @param type defined in java.sql.ResultSet
    * @return true if so 
    * @see Connection
    */
public boolean supportsResultSetType(int type) {
	if ((type == ResultSet.TYPE_FORWARD_ONLY) ||
	    (type == ResultSet.TYPE_SCROLL_INSENSITIVE)) {
		return true;
	}
   //we don't support TYPE_SCROLL_SENSITIVE yet.
   return false;
}
 

/**
 * Creates a key for a query with default settings.
 * <p>
 * Defaults are according to the JDBC standard; result set type will be
 * <code>ResultSet.TYPE_FORWARD_ONLY</code>, concurrency will be
 * <code>ResultSet.CONCUR_READ_ONLY</code> and the statement will not
 * return auto-generated keys.
 *
 * @param sql SQL query string
 * @param schema current compilation schema
 * @param holdability result set holdability
 * @return A statement key.
 */
public static StatementKey newPrepared(
        String sql, String schema, int holdability) {
    return new StatementKey(PREPARED, sql, schema,
            ResultSet.TYPE_FORWARD_ONLY,
            ResultSet.CONCUR_READ_ONLY,
            holdability, Statement.NO_GENERATED_KEYS);
}
 

/**
 * Creates a key for a query specifying whether auto-generated keys
 * shall be returned.
 * <p>
 * Unspecified settings will be according to the JDBC standard; result set
 * type will be <code>ResultSet.TYPE_FORWARD_ONLY</code>, concurrency will
 * be <code>ResultSet.CONCUR_READ_ONLY</code>.
 *
 * @param sql SQL query string
 * @param schema current compilation schema
 * @param holdability result set holdability
 * @param autogeneratedKeys tells whether or not to reutrn auto-generated
 *      keys
 * @return A statement key.
 */
public static StatementKey newPrepared(
        String sql, String schema, int holdability, int autogeneratedKeys) {
    return new StatementKey(PREPARED, sql, schema,
                            ResultSet.TYPE_FORWARD_ONLY,
                            ResultSet.CONCUR_READ_ONLY,
                            holdability, autogeneratedKeys);
}