/** * Method to apply any restrictions to the created ResultSet. * * @param ps The PreparedStatement * @param query The query * @param applyTimeout Whether to apply the query timeout (if any) direct to the PreparedStatement * @throws SQLException Thrown when an error occurs applying the constraints */ public static void prepareStatementForExecution( PreparedStatement ps, Query query, boolean applyTimeout) throws SQLException { NucleusContext nucleusCtx = query.getExecutionContext().getNucleusContext(); RDBMSStoreManager storeMgr = (RDBMSStoreManager) query.getStoreManager(); PersistenceConfiguration conf = nucleusCtx.getPersistenceConfiguration(); if (applyTimeout) { Integer timeout = query.getDatastoreReadTimeoutMillis(); if (timeout != null && timeout > 0) { ps.setQueryTimeout(timeout / 1000); } } // Apply any fetch size int fetchSize = 0; if (query.getFetchPlan().getFetchSize() > 0) { // FetchPlan has a size set so use that fetchSize = query.getFetchPlan().getFetchSize(); } if (storeMgr.getDatastoreAdapter().supportsQueryFetchSize(fetchSize)) { ps.setFetchSize(fetchSize); } // Apply any fetch direction String fetchDir = conf.getStringProperty(RDBMSPropertyNames.PROPERTY_RDBMS_QUERY_FETCH_DIRECTION); Object fetchDirExt = query.getExtension(RDBMSPropertyNames.PROPERTY_RDBMS_QUERY_FETCH_DIRECTION); if (fetchDirExt != null) { fetchDir = (String) fetchDirExt; if (!fetchDir.equals("forward") && !fetchDir.equals("reverse") && !fetchDir.equals("unknown")) { throw new NucleusUserException(LOCALISER.msg("052512")); } } if (fetchDir.equals("reverse")) { ps.setFetchDirection(ResultSet.FETCH_REVERSE); } else if (fetchDir.equals("unknown")) { ps.setFetchDirection(ResultSet.FETCH_UNKNOWN); } // Add a limit on the number of rows to include the maximum we may need long toExclNo = query.getRangeToExcl(); if (toExclNo != 0 && toExclNo != Long.MAX_VALUE) { if (toExclNo > Integer.MAX_VALUE) { // setMaxRows takes an int as input so limit to the correct range ps.setMaxRows(Integer.MAX_VALUE); } else { ps.setMaxRows((int) toExclNo); } } }
public void setFetchDirection(int direction) throws SQLException { Profiler profiler = _profilerPoint.start(); try { _preparedStatement.setFetchDirection(direction); } finally { profiler.finish(); } }
/** * 初始化真正的PreparedStatement,对当前对象的操作全部都设置到真正的PreparedStatement * * @throws SQLException */ private void prepare() throws SQLException { DALFactory dalFactory = DALFactory.getDefault(); List<Object> values = dalParameters.getValues(); Map<String, Object> context = new HashMap<String, Object>(); SQLStruct sqlStruct = dalFactory.getSqlAnalyzer().parse(sql, context); SQLInfo sqlInfo = null; if (sqlStruct.isCanParse()) { sqlInfo = dalFactory .getSqlAnalyzer() .analyse(sql, sqlStruct, values.toArray(new Object[values.size()]), context); } this.parsePartition(sqlStruct, sqlInfo); this.initRealPreparedStatement(); if (this.maxFieldSize != 0) { ps.setMaxFieldSize(maxFieldSize); } if (this.maxRows != 0) { ps.setMaxRows(maxRows); } if (!this.escapeProcessing) { ps.setEscapeProcessing(escapeProcessing); } if (this.queryTimeout != 0) { ps.setQueryTimeout(queryTimeout); } if (this.cursorName != null) { ps.setCursorName(cursorName); } if (this.fetchDirection != 0) { ps.setFetchDirection(fetchDirection); } if (this.fetchSize != 0) { ps.setFetchSize(fetchSize); } if (!this.poolable) { ps.setPoolable(poolable); } this.dalParameters.initRealPreparedStatement(ps); }
/** * Get the samples: <code>result_set</code> will have the samples, <code>value</code> will contain * the first sample * * @param start Start time * @param end End time * @throws Exception on error, including cancellation */ private void determineInitialSample(final Timestamp start, final Timestamp end) throws Exception { java.sql.Timestamp start_stamp = TimestampHelper.toSQLTimestamp(start); final java.sql.Timestamp end_stamp = TimestampHelper.toSQLTimestamp(end); // Get time of initial sample final PreparedStatement statement = reader.getRDB().getConnection().prepareStatement(reader.getSQL().sample_sel_initial_time); reader.addForCancellation(statement); try { statement.setInt(1, channel_id); statement.setTimestamp(2, start_stamp); final ResultSet result = statement.executeQuery(); if (result.next()) { // System.out.print("Start time corrected from " + start_stamp); start_stamp = result.getTimestamp(1); // Oracle has nanoseconds in TIMESTAMP, MySQL in separate column if (reader.getRDB().getDialect() == Dialect.MySQL || reader.getRDB().getDialect() == Dialect.PostgreSQL) start_stamp.setNanos(result.getInt(2)); // System.out.println(" to " + start_stamp); } } finally { reader.removeFromCancellation(statement); statement.close(); } // Fetch the samples if (reader.useArrayBlob()) sel_samples = reader .getRDB() .getConnection() .prepareStatement(reader.getSQL().sample_sel_by_id_start_end_with_blob); else sel_samples = reader .getRDB() .getConnection() .prepareStatement(reader.getSQL().sample_sel_by_id_start_end); sel_samples.setFetchDirection(ResultSet.FETCH_FORWARD); // Test w/ ~170000 raw samples: // 10 17 seconds // 100 6 seconds // 1000 4.x seconds // 10000 4.x seconds // 100000 4.x seconds // So default is bad. 100 or 1000 are good. // Bigger numbers don't help much in repeated tests, but // just to be on the safe side, use a bigger number. sel_samples.setFetchSize(Preferences.getFetchSize()); reader.addForCancellation(sel_samples); sel_samples.setInt(1, channel_id); sel_samples.setTimestamp(2, start_stamp); sel_samples.setTimestamp(3, end_stamp); result_set = sel_samples.executeQuery(); // Get first sample if (result_set.next()) value = decodeSampleTableValue(result_set, true); // else leave value null to indicate end of samples }
public void setFetchDirection(int direction) throws SQLException { this.fetchDirection = direction; if (ps != null) { ps.setFetchDirection(direction); } }
public void setFetchDirection(int direction) throws SQLException { statement.setFetchDirection(direction); }
public void setFetchDirection(int direction) throws SQLException { delegate.setFetchDirection(direction); }
@Override public void setFetchDirection(int direction) throws SQLException { stmt.setFetchDirection(direction); }