Java Code Examples for java.sql.ResultSet#TYPE_SCROLL_SENSITIVE

CassandraStatement(CassandraConnection con, String cql, int resultSetType, int resultSetConcurrency,
                   int resultSetHoldability) throws SQLException
{
    this.connection = con;
    this.cql = cql;
    this.batchQueries = Lists.newArrayList();
    
    this.consistencyLevel = con.defaultConsistencyLevel;

    if (!(resultSetType == ResultSet.TYPE_FORWARD_ONLY
          || resultSetType == ResultSet.TYPE_SCROLL_INSENSITIVE
          || resultSetType == ResultSet.TYPE_SCROLL_SENSITIVE)) throw new SQLSyntaxErrorException(BAD_TYPE_RSET);
    this.resultSetType = resultSetType;

    if (!(resultSetConcurrency == ResultSet.CONCUR_READ_ONLY
          || resultSetConcurrency == ResultSet.CONCUR_UPDATABLE)) throw new SQLSyntaxErrorException(BAD_TYPE_RSET);
    this.resultSetConcurrency = resultSetConcurrency;


    if (!(resultSetHoldability == ResultSet.HOLD_CURSORS_OVER_COMMIT
          || resultSetHoldability == ResultSet.CLOSE_CURSORS_AT_COMMIT))
        throw new SQLSyntaxErrorException(BAD_HOLD_RSET);
    this.resultSetHoldability = resultSetHoldability;
}
 

/**
 * Returns the resultType if set if not set returns the default
 * java.sql.ResultSet.TYPE_FORWARD_ONLY
 */
static int getResultType(StatementAttrs attrs) {
  int rsType;
  if (attrs != null && attrs.isSetResultSetType()) {
    rsType = attrs.getResultSetType();
  }
  else {
    rsType = gfxdConstants.DEFAULT_RESULTSET_TYPE;
  }
  switch (rsType) {
    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 InternalGemFireError("unknown resultSet type "
          + attrs.getResultSetType());
  }
}
 

private int setResultSetType(int resultSetType) {

		/* Add warning if scroll sensitive cursor
		 * and downgrade to scroll insensitive cursor.
		 */
		if (resultSetType == ResultSet.TYPE_SCROLL_SENSITIVE)
		{
			addWarning(SQLWarningFactory.newSQLWarning(SQLState.NO_SCROLL_SENSITIVE_CURSORS));
			resultSetType = ResultSet.TYPE_SCROLL_INSENSITIVE;
		}
		return resultSetType;
	}
 

@Override
public Statement createStatement(int resultSetType, int resultSetConcurrency)
    throws SQLException {
  if (resultSetConcurrency != ResultSet.CONCUR_READ_ONLY) {
    throw new SQLException(
        String.format("Statements with result set concurrency %d are not supported",
            resultSetConcurrency));
  }
  if (resultSetType == ResultSet.TYPE_SCROLL_SENSITIVE) {
    throw new SQLException(String.format("Statements with ResultSet type %d are not supported",
        resultSetType));
  }
  return new IoTDBStatement(this, getClient(), sessionId, zoneId);
}
 

@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}
    };
}
 

/**
    * JDBC 2.0
    *
    * Does the database support the concurrency type in combination
    * with the given result set type?
    *
    * @param type defined in java.sql.ResultSet
    * @param concurrency type defined in java.sql.ResultSet
    * @return true if so 
    * @see Connection
    */
public boolean supportsResultSetConcurrency(int type, int concurrency) {
		if (type == ResultSet.TYPE_SCROLL_SENSITIVE) {
			// (TYPE_SCROLL_SENSITIVE, *)
 			return false;
		} else {
			// (FORWARD_ONLY, CONCUR_UPDATABLE)
			// (FORWARD_ONLY, CONCUR_READ_ONLY)
			// (TYPE_SCROLL_INSENSITIVE, CONCUR_UPDATABLE)
			// (TYPE_SCROLL_INSENSITIVE, READ_ONLY)
			return true;
		}
}
 

/**
 * Determine if DBMS/Driver supports scrollable resultsets to be able to
 * determine complete row count for a given SQL.
 *
 * @param conn established JDBC connection
 * @param dc connection information
 * @param sql the sql to be executed
 */
private void updateScrollableSupport(Connection conn, DatabaseConnection dc,
        String sql) {
    useScrollableCursors = dc.isUseScrollableCursors();
    if (!useScrollableCursors) {
        return;
    }
    String driverName = dc.getDriverClass();
    /* Derby fails to support scrollable cursors when invoking 'stored procedures'
     which return resultsets - it fails hard: not throwing a SQLException,
     but terminating the connection - so don't try to use scrollable cursor
     on derby, for "non"-selects */
    if (driverName != null && driverName.startsWith("org.apache.derby")) { //NOI18N
        if (!isSelectStatement(sql)) {
            resultSetScrollType = ResultSet.TYPE_FORWARD_ONLY;
            return;
        }
    }
    /* Try to get a "good" scrollable ResultSet and follow the DBs support */
    try {
        if (conn.getMetaData().supportsResultSetType(
                ResultSet.TYPE_SCROLL_INSENSITIVE)) {
            resultSetScrollType = ResultSet.TYPE_SCROLL_INSENSITIVE;
        } else if (conn.getMetaData().supportsResultSetType(
                ResultSet.TYPE_SCROLL_SENSITIVE)) {
            resultSetScrollType = ResultSet.TYPE_SCROLL_SENSITIVE;
        }
    } catch (Exception ex) {
        LOGGER.log(Level.WARNING, "Exception while querying" //NOI18N
                + " database for scrollable resultset support"); //NOI18N
    }
}
 

@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}
    };
}
 

private static int getResultSetType(RuntimeProperties props) throws BarleyDBQueryException {
    if (props.getScrollType() == null) {
        return ResultSet.TYPE_FORWARD_ONLY;
    }
    switch(props.getScrollType()) {
        case FORWARD_ONLY:
            return ResultSet.TYPE_FORWARD_ONLY;
        case SCROLL_INSENSITIVE:
            return ResultSet.TYPE_SCROLL_INSENSITIVE;
        case SCROLL_SENSITIVE:
            return ResultSet.TYPE_SCROLL_SENSITIVE;
        default:
            throw new IllegalQueryStateException("Unknown scroll type '" + props.getScrollType() + "'");
    }
}
 

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

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);
  }
}
 

private int setResultSetType(int resultSetType) {
	/* Add warning if scroll sensitive cursor
	 * and downgrade to scroll insensitive cursor.
	 */
	if (resultSetType == ResultSet.TYPE_SCROLL_SENSITIVE)
	{
		addWarning(SQLWarningFactory.newSQLWarning(SQLState.NO_SCROLL_SENSITIVE_CURSORS));
		resultSetType = ResultSet.TYPE_SCROLL_INSENSITIVE;
	}
	return resultSetType;
}
 

/**
    * JDBC 2.0
    *
    * Does the database support the concurrency type in combination
    * with the given result set type?
    *
    * @param type defined in java.sql.ResultSet
    * @param concurrency type defined in java.sql.ResultSet
    * @return true if so 
    * @see Connection
    */
public boolean supportsResultSetConcurrency(int type, int concurrency) {
		if (type == ResultSet.TYPE_SCROLL_SENSITIVE) {
			// (TYPE_SCROLL_SENSITIVE, *)
 			return false;
		} else {
			// (FORWARD_ONLY, CONCUR_UPDATABLE)
			// (FORWARD_ONLY, CONCUR_READ_ONLY)
			// (TYPE_SCROLL_INSENSITIVE, CONCUR_UPDATABLE)
			// (TYPE_SCROLL_INSENSITIVE, READ_ONLY)
			return true;
		}
}
 

private int setResultSetType(int resultSetType) {
	/* Add warning if scroll sensitive cursor
	 * and downgrade to scroll insensitive cursor.
	 */
	if (resultSetType == ResultSet.TYPE_SCROLL_SENSITIVE)
	{
		addWarning(SQLWarningFactory.newSQLWarning(SQLState.NO_SCROLL_SENSITIVE_CURSORS));
		resultSetType = ResultSet.TYPE_SCROLL_INSENSITIVE;
	}
	return resultSetType;
}
 

private boolean isScrollable() {
    return (this.resultSetType == ResultSet.TYPE_SCROLL_INSENSITIVE ||
            this.resultSetType == ResultSet.TYPE_SCROLL_SENSITIVE);
}
 

/**
 * 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);
    }
}
 

/**
 * 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);
    }
}
 

/**
 * Default to {@link ResultSet#TYPE_SCROLL_SENSITIVE}, meaning that a change in the underlying
 * database may affect the result set.
 */
@Override
public int getResultSetType() throws SQLException {
    return ResultSet.TYPE_SCROLL_SENSITIVE;
}
 

private void loadDataFrom(final DataViewPageContext pageContext, ResultSet rs) throws SQLException, InterruptedException {
    if (rs == null) {
        return;
    }

    int pageSize = pageContext.getPageSize();
    int startFrom;
    if (useScrollableCursors ) {
        startFrom = pageContext.getCurrentPos(); // will use rs.absolute
    } else if (!limitSupported || isLimitUsedInSelect(dataView.getSQLString())) {
        startFrom = pageContext.getCurrentPos(); // need to use slow skip
    } else {
        startFrom = 0; // limit added to select, can start from first item
    }

    final List<Object[]> rows = new ArrayList<>();
    int colCnt = pageContext.getTableMetaData().getColumnCount();
    int curRowPos = 0;
    try {
        long start = System.currentTimeMillis();
        boolean hasNext = false;
        boolean needSlowSkip = true;

        if (useScrollableCursors
                && (rs.getType() == ResultSet.TYPE_SCROLL_INSENSITIVE
                || rs.getType() == ResultSet.TYPE_SCROLL_SENSITIVE)) {
            try {
                hasNext = rs.absolute(startFrom);
                curRowPos = rs.getRow();
                needSlowSkip = false;
            } catch (SQLException ex) {
                LOGGER.log(Level.FINE, "Absolute positioning failed", ex); // NOI18N
            }
        }

        if (needSlowSkip) {
            // Skip till current position
            hasNext = rs.next();
            curRowPos++;
            while (hasNext && curRowPos < startFrom) {
                if (Thread.interrupted()) {
                    throw new InterruptedException();
                }
                hasNext = rs.next();
                curRowPos++;
            }
        }
        
        // Get next page
        int rowCnt = 0;
        while (((pageSize <= 0) || (pageSize > rowCnt)) && (hasNext)) {
            if (Thread.interrupted()) {
                throw new InterruptedException();
            }

            Object[] row = new Object[colCnt];
            for (int i = 0; i < colCnt; i++) {
                row[i] = DBReadWriteHelper.readResultSet(rs,
                        pageContext.getTableMetaData().getColumn(i), i + 1);
            }
            rows.add(row);
            rowCnt++;
            try {
                hasNext = rs.next();
                curRowPos++;
            } catch (SQLException x) {
                LOGGER.log(Level.INFO, "Failed to forward to next record, cause: " + x.getLocalizedMessage(), x);
                hasNext = false;
            }
        }
        
        long end = System.currentTimeMillis();
        
        dataView.addFetchTime(end - start);
    } catch (SQLException e) {
        LOGGER.log(Level.INFO, "Failed to set up table model.", e); // NOI18N
        throw e;
    } finally {
        Mutex.EVENT.writeAccess(new Runnable() {
            @Override
            public void run() {
                pageContext.getModel().setData(rows);
                pageContext.getModel().setRowOffset(pageContext.getCurrentPos() - 1);
            }
        });
    }
}