public List<JobHistoryStatus> getJobHistoryStatuses(String filter) throws Exception { List<JobHistoryStatus> statuses = new ArrayList<JobHistoryStatus>(); String strSQL = ""; ResultSet rs = null; try { strSQL = "SELECT id,name,description FROM jobhistorystatus "+filter; rs = this.sqlExecuteSelect(strSQL); if (rs != null) { while (rs.next()) { JobHistoryStatus status = new JobHistoryStatus(); status.setId(rs.getString("id")); status.setName(rs.getString("name")); status.setDescription(rs.getString("description")); statuses.add(status); } if (rs.getStatement() != null) { rs.getStatement().close(); } rs.close(); } } catch (SQLException e) { throw new Exception(e.getMessage()); } finally { this.closeConnection(); } return statuses; }
public void doCleanup(Database db) { try { if (contract != null) contract.getStatement().close(); if (item != null) item.getStatement().close(); } catch (SQLException e) { } }
/** * INTERNAL: Get a timestamp value from a result set. Overrides the default behavior to * specifically return a timestamp. Added to overcome an issue with the oracle 9.0.1.4 JDBC * driver. */ public Object getObjectFromResultSet( ResultSet resultSet, int columnNumber, int type, AbstractSession session) throws java.sql.SQLException { // Bug#3381652 10G Drivers return sql.Date instead of timestamp on DATE field if ((type == Types.TIMESTAMP) || (type == Types.DATE)) { return resultSet.getTimestamp(columnNumber); } else if (type == OracleTypes.TIMESTAMPTZ) { TIMESTAMPTZ tsTZ = (TIMESTAMPTZ) resultSet.getObject(columnNumber); // Need to call timestampValue once here with the connection to avoid null point // exception later when timestampValue is called in converObject() if ((tsTZ != null) && (tsTZ.getLength() != 0)) { Connection connection = getConnection(session, resultSet.getStatement().getConnection()); // Bug#4364359 Add a wrapper to overcome TIMESTAMPTZ not serializable as of jdbc 9.2.0.5 // and 10.1.0.2. // It has been fixed in the next version for both streams return new TIMESTAMPTZWrapper(tsTZ, connection, isTimestampInGmt(connection)); } return null; } else if (type == OracleTypes.TIMESTAMPLTZ) { // TIMESTAMPLTZ needs to be converted to Timestamp here because it requires the connection. // However the java object is not know here. The solution is to store Timestamp and the // session timezone in a wrapper class, which will be used later in converObject(). TIMESTAMPLTZ tsLTZ = (TIMESTAMPLTZ) resultSet.getObject(columnNumber); if ((tsLTZ != null) && (tsLTZ.getLength() != 0)) { Timestamp ts = TIMESTAMPLTZ.toTimestamp( getConnection(session, resultSet.getStatement().getConnection()), tsLTZ.toBytes()); // Bug#4364359 Add a separate wrapper for TIMESTAMPLTZ. return new TIMESTAMPLTZWrapper( ts, ((OracleConnection) getConnection(session, resultSet.getStatement().getConnection())) .getSessionTimeZone()); } return null; } else if (type == OracleTypes.OPAQUE) { try { Object result = resultSet.getObject(columnNumber); if (!(result instanceof OPAQUE)) { // Report Queries can cause result to not be an instance of OPAQUE. return result; } return getXMLTypeFactory().getString((OPAQUE) result); } catch (SQLException ex) { throw DatabaseException.sqlException(ex, null, session, false); } } else { Object value = super.getObjectFromResultSet(resultSet, columnNumber, type, session); if (type == OracleTypes_NCLOB) { value = convertObject(value, ClassConstants.STRING); } return value; } }
protected void assertBackPointers(Connection conn, Statement statement) throws SQLException { assertFalse(conn.isClosed()); assertFalse(isClosed(statement)); assertSame( "statement.getConnection() should return the exact same connection instance that was used to create the statement", conn, statement.getConnection()); ResultSet resultSet = statement.getResultSet(); assertFalse(isClosed(resultSet)); assertSame( "resultSet.getStatement() should return the exact same statement instance that was used to create the result set", statement, resultSet.getStatement()); ResultSet executeResultSet = statement.executeQuery("select * from dual"); assertFalse(isClosed(executeResultSet)); assertSame( "resultSet.getStatement() should return the exact same statement instance that was used to create the result set", statement, executeResultSet.getStatement()); ResultSet keysResultSet = statement.getGeneratedKeys(); assertFalse(isClosed(keysResultSet)); assertSame( "resultSet.getStatement() should return the exact same statement instance that was used to create the result set", statement, keysResultSet.getStatement()); ResultSet preparedResultSet = null; if (statement instanceof PreparedStatement) { PreparedStatement preparedStatement = (PreparedStatement) statement; preparedResultSet = preparedStatement.executeQuery(); assertFalse(isClosed(preparedResultSet)); assertSame( "resultSet.getStatement() should return the exact same statement instance that was used to create the result set", statement, preparedResultSet.getStatement()); } resultSet.getStatement().getConnection().close(); assertTrue(conn.isClosed()); assertTrue(isClosed(statement)); assertTrue(isClosed(resultSet)); assertTrue(isClosed(executeResultSet)); assertTrue(isClosed(keysResultSet)); if (preparedResultSet != null) { assertTrue(isClosed(preparedResultSet)); } }
@Test public void testNewResultSet_GetMergeCost() throws Exception { // Mocks ConnectionManager connectionManager = mock(ConnectionManager.class); Connection connection = mock(Connection.class); PreparedStatement preparedStatement = mock(PreparedStatement.class); java.sql.ResultSet resultSet = mock(java.sql.ResultSet.class); // Behaviour when(connectionManager.getConnection(any(SQLiteIndex.class))).thenReturn(connection); when(connection.prepareStatement( "SELECT COUNT(objectKey) FROM " + TABLE_NAME + " WHERE value = ?;")) .thenReturn(preparedStatement); when(preparedStatement.executeQuery()).thenReturn(resultSet); when(resultSet.getStatement()).thenReturn(preparedStatement); when(resultSet.next()).thenReturn(true); when(resultSet.getInt(1)).thenReturn(3); // Iterator ResultSet<Car> carsWithAbs = new SQLiteIndex<String, Car, Integer>( Car.FEATURES, OBJECT_TO_ID, ID_TO_OBJECT, connectionManager) .retrieve(equal(Car.FEATURES, "abs"), new QueryOptions()); Assert.assertNotNull(carsWithAbs); int size = carsWithAbs.getMergeCost(); assertEquals(3, size); verify(connection, times(1)).close(); }
/** * 获取游戏接口参数 * * @param id * 游戏接口参数编号 * @return 游戏接口参数 */ public wh.game.model.GameInterfaceParams get(int id) throws Exception{ wh.game.model.GameInterfaceParams model = null; Map<String, Object> inParameters = new HashMap<String, Object>(); inParameters.put("GameInterfaceParamsId", id); OutParameters outParameters = new OutParameters(); outParameters.putOutParmType("ErrNo", java.sql.Types.INTEGER); outParameters.putOutParmType("ErrMsg", java.sql.Types.NVARCHAR); ResultSet rs = null; CallableStatement cstmt = null; int errNo = 0; String errMsg = ""; try { rs = SQLHelper.runProcedure(Config.CONNECTION_STRING_ULD, "{call WH_Game_GameInterfaceParams_Get(?,?,?)}", inParameters, outParameters); if (rs != null) { rs.next(); model = getModel(rs); cstmt = (CallableStatement)rs.getStatement(); errNo = cstmt.getInt("ErrNo"); errMsg = cstmt.getString("ErrMsg"); } } catch (Exception e) { throw new Exception(e.getMessage(), e); } finally{ SQLHelper.closeAll(cstmt); } MyErr.checkErr(errNo, errMsg); return model; }
@OnReturn public static void onReturn( @BindReturn boolean currentRowValid, @BindTarget ResultSet resultSet) { try { Statement statement = resultSet.getStatement(); if (statement == null) { // this is not a statement execution, it is some other execution of // ResultSet.next(), e.g. Connection.getMetaData().getTables().next() return; } StatementMirror mirror = getStatementMirror(statement); JdbcMessageSupplier lastJdbcMessageSupplier = mirror.getLastJdbcMessageSupplier(); if (lastJdbcMessageSupplier == null) { // tracing must be disabled (e.g. exceeded span limit per trace) return; } if (currentRowValid) { lastJdbcMessageSupplier.updateNumRows(resultSet.getRow()); } else { lastJdbcMessageSupplier.setHasPerformedNavigation(); } } catch (SQLException e) { logger.warn(e.getMessage(), e); } }
public QueryResponse getResponse(Connection connection) { QueryResponse response = new QueryResponse(); String sqlQuery = getSqlQuery(); ResultSet rs = null; try { rs = getResultSet(connection, sqlQuery); handleResult(rs, response); } finally { if (rs != null) { if (debug) TPFDDLoggerFactory.createLogger() .logMessage( Logger.NORMAL, Logger.GENERIC, "SqlQuery.getResponse closing result set."); try { rs.close(); rs.getStatement().close(); } catch (SQLException e) { TPFDDLoggerFactory.createLogger() .logMessage( Logger.NORMAL, Logger.GENERIC, "SqlQuery.getResponse - closing result set, got sql error : (" + e.getErrorCode() + ") " + e); } } } return response; }
/** * Checks the database for if the name of the player exists. The name is formated automatically in * the method for checking the database, so no conversion is required. * * @param name Name to check for in the database * @return Returns True if the player exists */ public boolean playerExists(String name) { if (!name.equals("")) { if (name.contains(" ")) { name = name.split(" ")[0]; } name = name.toLowerCase(); try { PreparedStatement ps = databaseConnection.preparedStatement( "SELECT id FROM characters WHERE LOWER(\"firstName\")=?"); ps.setString(1, name); ResultSet resultSet = ps.executeQuery(); boolean isDuplicate = resultSet.next(); resultSet.getStatement().close(); if (isDuplicate) { return true; } else { return false; } } catch (SQLException e) { e.printStackTrace(); } } return false; }
public String getLtDate(GSPPersistentEngine engine) throws SQLException, Exception { Connection c = null; ResultSet rs = null; String rValue = ""; try { c = engine.getConnection(); rs = engine.executeQuery("select to_char(sysdate,'mmdd') " + "from dual", c); rs.next(); rValue = rs.getString(1); } finally { if (rs != null) { rs.getStatement().close(); rs.close(); rs = null; } if (c != null) { engine.free(c); c = null; } } return rValue; }
@SuppressWarnings("unchecked") private <X> List<X> selectSimple(X x, boolean distinct) { SQLStatement stat = getSelectStatement(distinct); appendSQL(stat, x); appendFromWhere(stat); ResultSet rs = stat.executeQuery(); List<X> result = New.arrayList(); Statement s = null; try { s = rs.getStatement(); while (rs.next()) { try { X value; Object o = rs.getObject(1); int convertHereIsProbablyWrong; if (Clob.class.isAssignableFrom(o.getClass())) { value = (X) ClassUtils.convert(o, String.class); } else { value = (X) o; } result.add(value); } catch (Exception e) { throw new RuntimeException(e); } } } catch (SQLException e) { throw new RuntimeException(e); } finally { JdbcUtils.closeSilently(rs); JdbcUtils.closeSilently(s); } return result; }
public boolean isDate(GSPPersistentEngine engine, String date) throws SQLException, Exception { boolean rvalue = true; Connection c = null; ResultSet rs = null; try { c = engine.getConnection(); String sql = "select " + "to_date(?,'yyyymmdd') " + "from dual"; Object[] value = new Object[1]; value[0] = date; rs = engine.executePrepareQuery(sql, value, c); rs.next(); } catch (SQLException e) { rvalue = false; } finally { if (rs != null) { rs.getStatement().close(); rs.close(); rs = null; } if (c != null) { engine.free(c); c = null; } } return rvalue; }
public String getDBDateMSSQL(GSPPersistentEngine engine) throws SQLException, Exception { Connection c = null; ResultSet rs = null; String rValue = ""; try { c = engine.getConnection(); rs = engine.executeQuery("select getdate()", c); rs.next(); Date dbDate = rs.getDate(1); rValue = DateToString(dbDate, "ddMMyyyy"); } finally { if (rs != null) { rs.getStatement().close(); rs.close(); rs = null; } if (c != null) { engine.free(c); c = null; } } return rValue; }
public String getDBDate(GSPPersistentEngine engine, String format) throws SQLException, Exception { Connection c = null; ResultSet rs = null; String rValue = ""; try { c = engine.getConnection(); rs = engine.executeQuery("select sysdate as toDate " + "from dual", c); rs.next(); Date dbDate = rs.getDate(1); rValue = DateToString(dbDate, format); } finally { if (rs != null) { rs.getStatement().close(); rs.close(); rs = null; } if (c != null) { engine.free(c); c = null; } } return rValue; }
public static String getTgl(GSPPersistentEngine engine) throws ISOException, SQLException, Exception { String rvalue = ""; Connection c = null; ResultSet rs = null; c = engine.getConnection(); String sql = "select date_format(sysdate(),'%Y%m%d') "; rs = engine.executeQuery(sql, c); if (rs.next()) { rvalue = rs.getString(1); } if (rs != null) { rs.getStatement().close(); rs.close(); rs = null; } if (c != null) { engine.free(c); c = null; } return rvalue; }
public int getDBTime(GSPPersistentEngine engine) throws SQLException, Exception { Connection c = null; ResultSet rs = null; int rvalue = 0; try { c = engine.getConnection(); rs = engine.executeQuery("select to_char(sysdate,'hh24:mm:ss') as time " + "from dual", c); rs.next(); String t = rs.getString(1); String hh = t.substring(0, 2); String mm = t.substring(3, 5); String ss = t.substring(6, 8); rvalue = Integer.parseInt(hh + mm + ss); } finally { if (rs != null) { rs.getStatement().close(); rs.close(); rs = null; } if (c != null) { engine.free(c); c = null; } } return rvalue; }
@Override public void register(ResultSet resultSet, Statement statement) { log.tracef("Registering result set [%s]", resultSet); if (statement == null) { try { statement = resultSet.getStatement(); } catch (SQLException e) { throw convert(e, "unable to access Statement from ResultSet"); } } if (statement != null) { // Keep this at DEBUG level, rather than warn. Numerous connection pool implementations can // return a // proxy/wrapper around the JDBC Statement, causing excessive logging here. See HHH-8210. if (log.isDebugEnabled() && !xref.containsKey(statement)) { log.debug("ResultSet statement was not registered (on register)"); } Set<ResultSet> resultSets = xref.get(statement); if (resultSets == null) { resultSets = new HashSet<ResultSet>(); xref.put(statement, resultSets); } resultSets.add(resultSet); } else { unassociatedResultSets.add(resultSet); } }
@Override public void release(ResultSet resultSet, Statement statement) { log.tracef("Releasing result set [%s]", resultSet); if (statement == null) { try { statement = resultSet.getStatement(); } catch (SQLException e) { throw convert(e, "unable to access Statement from ResultSet"); } } if (statement != null) { final Set<ResultSet> resultSets = xref.get(statement); if (resultSets == null) { log.unregisteredStatement(); } else { resultSets.remove(resultSet); if (resultSets.isEmpty()) { xref.remove(statement); } } } else { final boolean removed = unassociatedResultSets.remove(resultSet); if (!removed) { log.unregisteredResultSetWithoutStatement(); } } close(resultSet); }
public long DateDiff(GSPPersistentEngine engine, String start, String end) throws SQLException, Exception { long dayDiff = 0; Connection c = null; ResultSet rs = null; try { c = engine.getConnection(); String sql = "select " + "to_date(?,'DDMMYYYY') - " + "to_date(?, 'DDMMYYYY') dayDiff " + "from dual"; Object[] value = new Object[2]; value[0] = end; value[1] = start; rs = engine.executePrepareQuery(sql, value, c); rs.next(); dayDiff = rs.getLong(1); } finally { if (rs != null) { rs.getStatement().close(); rs.close(); rs = null; } if (c != null) { engine.free(c); c = null; } } return dayDiff; }
public String getDBDate(GSPPersistentEngine engine, int diff) throws SQLException, Exception { Connection c = null; ResultSet rs = null; String rValue = ""; try { c = engine.getConnection(); String sql = "select sysdate + ? as toDate " + "from dual"; Object[] value = new Object[1]; value[0] = diff; rs = engine.executePrepareQuery(sql, value, c); rs.next(); Date dbDate = rs.getDate(1); rValue = DateToString(dbDate, "ddMMyyyy"); } finally { if (rs != null) { rs.getStatement().close(); rs.close(); rs = null; } if (c != null) { engine.free(c); c = null; } } return rValue; }
/** Closes a result set */ public static void close(ResultSet rs) { try { close(rs.getStatement()); } catch (SQLException e) { } try { if (rs != null) rs.close(); } catch (SQLException e) { } }
private static FTPPercentilesSession generatePercentiles( ResultSet resultSet, HashMap<String, Double> medias) throws SQLException { FTPPercentilesSession ftpPercentileSession = new FTPPercentilesSession(); ftpPercentileSession.setOperatorName(resultSet.getString("OperatorName")); ftpPercentileSession.setLocalidade( Core.getLocalidade(resultSet.getStatement().getConnection().getMetaData().getURL())); ftpPercentileSession.setTecnologia( Core.getTecnologia(resultSet.getStatement().getConnection().getMetaData().getURL())); ftpPercentileSession.setOperations(resultSet.getString("operation")); ftpPercentileSession.setNumSuccess(resultSet.getInt("numSuccess")); ftpPercentileSession.setNumFailed(resultSet.getInt("numFailed")); ftpPercentileSession.setCommitment( new Double(resultSet.getString("commitment")) / (1000.0 * 1000.0)); ftpPercentileSession.setMedia(medias.get("mediaPonderada")); return ftpPercentileSession; }
/** * Process a query and returns only the first result of a result set as a String. To be used when * it is certain that only one String (single cell) will be returned from the DB * * @param conn The Connection object to which the DML should be sent * @param query The query statements to be processed * @return String with the result returned from the database * @throws SQLException */ public static String processQueryWithSingleResult(Connection conn, String query) throws SQLException { try (Statement sm = SQLUtil.executeQueryWithResults(conn, query); ResultSet rs = sm.getResultSet()) { rs.next(); String result = rs.getString(1); rs.getStatement().close(); return result; } }
/* * (non-Javadoc) * * @see org.talend.dataprofiler.core.sampling.SamplingDataSource#finalizeDataSampling() */ public boolean finalizeDataSampling() throws Exception { if (jdbcResultSet != null) { Statement statement = jdbcResultSet.getStatement(); Connection connection = statement.getConnection(); jdbcResultSet.close(); statement.close(); connection.close(); } return true; }
/** * close current result set, discarding all items in result set and local tuple variables * precondition: successful call to fetchTuple() */ public void close() throws SQLException { log.info("Table_ServiceLayer::close()"); resultSet.getStatement().close(); resultSet.close(); resultSet = null; tupleValid = false; log.info("Table_ServiceLayer::close()"); }
// 根据id查询 public TRegister searchByID(int id) throws Exception { Connection dbConn = DataBaseTool.getConnection(); String sql = "select * from t_register where id=" + id; ResultSet rs = DataBaseTool.executeQuery(dbConn, sql); TRegister register = null; while (rs.next()) { register = new TRegister(); setOne(register, rs); } DataBaseTool.close(rs, rs.getStatement(), dbConn); return register; }
/** * Returns a List of FsContent objects from TSK based on sql query. * * @param image is a Image object that denotes which image to get the files from * @param query is a sql string query that is to be run * @return FFSqlitedb is a List of FsContent objects */ public List<FsContent> extractFiles(Image image, String query) { Collection<FileSystem> imageFS = tskCase.getFileSystems(image); List<String> fsIds = new LinkedList<String>(); for (FileSystem img : imageFS) { Long tempID = img.getId(); fsIds.add(tempID.toString()); } String allFS = new String(); for (int i = 0; i < fsIds.size(); i++) { if (i == 0) { allFS += " AND (0"; } allFS += " OR fs_obj_id = '" + fsIds.get(i) + "'"; if (i == fsIds.size() - 1) { allFS += ")"; } } List<FsContent> FFSqlitedb = null; try { ResultSet rs = tskCase.runQuery(query + allFS); FFSqlitedb = tskCase.resultSetToFsContents(rs); Statement s = rs.getStatement(); rs.close(); if (s != null) { s.close(); } rs.close(); rs.getStatement().close(); } catch (SQLException ex) { logger.log( Level.WARNING, "Error while trying to extract files for:" + this.getClass().getName(), ex); this.addErrorMessage(this.getName() + ": Error while trying to extract files to analyze."); } return FFSqlitedb; }
protected void getPersistantObject() throws Exception { String query = "SELECT id, name, description FROM jobhistorystatus WHERE id =" + this.getId(); try { ResultSet rs = this.sqlExecuteSelect(query); if (rs != null) { if (rs.next()) { this.setId(rs.getString("id")); this.setName(rs.getString("name")); this.setDescription(rs.getString("description")); } if (rs.getStatement() != null) { rs.getStatement().close(); } rs.close(); } } catch (Exception e) { throw new Exception(e.getMessage()); } finally { this.closeConnection(); } }
private boolean checkForDuplicateName(String firstName, long accountId) throws SQLException { firstName = firstName.replace("'", "''"); firstName = firstName.toLowerCase(); PreparedStatement ps = databaseConnection.preparedStatement( "SELECT id FROM characters WHERE LOWER(\"firstName\")=?"); ps.setString(1, firstName); // System.out.println(ps.toString()); ResultSet resultSet = ps.executeQuery(); boolean isDuplicate = resultSet.next(); resultSet.getStatement().close(); if (isDuplicate) { return true; } // FIXME: this is a bit lazy... but it's only temporary :p PreparedStatement psc = databaseConnection.preparedStatement("SELECT * FROM pg_tables WHERE \"tablename\"=?"); psc.setString(1, "temp_reserved_char_names"); ResultSet resultSetC = psc.executeQuery(); boolean tableExists = resultSetC.next(); resultSetC.getStatement().close(); if (!tableExists) { return false; } PreparedStatement ps2 = databaseConnection.preparedStatement( "SELECT \"accountId\" FROM temp_reserved_char_names WHERE \"accountId\"!=? AND LOWER(\"firstName\")=?"); ps2.setLong(1, accountId); ps2.setString(2, firstName.toLowerCase()); ResultSet resultSet2 = ps2.executeQuery(); boolean isReserved = resultSet2.next(); resultSet2.getStatement().close(); return isReserved; }
private void validateColumn(Connection connection, String columnName, int expectedJdbcTypeCode) throws SQLException { DatabaseMetaData meta = connection.getMetaData(); // DBs treat the meta information differently, in particular case sensitivity. // We need to use the meta information to find out how to treat names String tableNamePattern = generateFinalNamePattern(meta, SOME_ENTITY_TABLE_NAME); String columnNamePattern = generateFinalNamePattern(meta, columnName); ResultSet columnInfo = meta.getColumns(null, null, tableNamePattern, columnNamePattern); s.getTransactionCoordinator() .getJdbcCoordinator() .register(columnInfo, columnInfo.getStatement()); assertTrue(columnInfo.next()); int dataType = columnInfo.getInt("DATA_TYPE"); s.getTransactionCoordinator() .getJdbcCoordinator() .release(columnInfo, columnInfo.getStatement()); assertEquals( columnName, JdbcTypeNameMapper.getTypeName(expectedJdbcTypeCode), JdbcTypeNameMapper.getTypeName(dataType)); }