@Override public Statement getStatement() throws SQLException { return rs.getStatement(); }
@Override public Statement getStatement() throws SQLException { return delegate.getStatement(); }
@Override public Statement resultSet_getStatement(ResultSetProxy resultSet) throws SQLException { if (this.pos < filterSize) { return nextFilter().resultSet_getStatement(this, resultSet); } return resultSet.getResultSetRaw().getStatement(); }
@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 ) { Set<ResultSet> resultSets = xref.get( statement ); // 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() && resultSets == null ) { log.debug( "ResultSet statement was not registered (on register)" ); } if ( resultSets == null || resultSets == Collections.EMPTY_SET ) { resultSets = new HashSet<ResultSet>(); xref.put( statement, resultSets ); } resultSets.add( resultSet ); } else { unassociatedResultSets.add( resultSet ); } }
int typeCode = (int) buffer.getUInt(); Connection connection = rs.getStatement().getConnection();
statement = resultSet.getStatement();
public PdxInstance create() throws SQLException { if (!resultSet.next()) { return null; } TypeRegistry typeRegistry = cache.getPdxRegistry(); ResultSetMetaData metaData = resultSet.getMetaData(); final int columnCount = metaData.getColumnCount(); for (int i = 1; i <= columnCount; i++) { String columnName = metaData.getColumnName(i); String fieldName = regionMapping.getFieldNameForColumn(columnName, typeRegistry); FieldType fieldType = getFieldType(typeRegistry, fieldName); writeField(columnName, i, fieldName, fieldType); } if (resultSet.next()) { throw new JdbcConnectorException( "Multiple rows returned for query: " + resultSet.getStatement()); } return factory.create(); }
@Override public void close() { synchronized (results) { if (!closed) { Statement statement = null; if (closeStatement) { try { statement = results.getStatement(); } catch (SQLException ignored) { } } closeSuppressed(results); if (statement != null) { Connection connection = null; try { connection = statement.getConnection(); } catch (SQLException ignored) { } closeSuppressed(statement); if (closeConnection) { closeSuppressed(connection); } } closed = true; } } }
@Test public void throwsExceptionIfMoreThanOneResultReturned() throws Exception { setupResultSet(resultSet, FieldType.OBJECT); when(resultSet.next()).thenReturn(true); when(resultSet.getStatement()).thenReturn(mock(PreparedStatement.class)); PdxInstanceFactory factory = mock(PdxInstanceFactory.class); String pdxClassName = "myPdxClassName"; when(cache.createPdxInstanceFactory(pdxClassName)).thenReturn(factory); TypeRegistry pdxTypeRegistry = mock(TypeRegistry.class); when(cache.getPdxRegistry()).thenReturn(pdxTypeRegistry); PdxType pdxType = mock(PdxType.class); when(regionMapping.getPdxName()).thenReturn(pdxClassName); when(pdxTypeRegistry.getPdxTypeForField(PDX_FIELD_NAME_1, pdxClassName)).thenReturn(pdxType); PdxField pdxField = mock(PdxField.class); when(pdxField.getFieldType()).thenReturn(FieldType.OBJECT); when(pdxType.getPdxField(PDX_FIELD_NAME_1)).thenReturn(pdxField); when(regionMapping.getFieldNameForColumn(eq(COLUMN_NAME_1), any())) .thenReturn(PDX_FIELD_NAME_1); thrown.expect(JdbcConnectorException.class); thrown.expectMessage("Multiple rows returned for query: "); createPdxInstance(); }
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.getJdbcCoordinator().getResourceRegistry().register(columnInfo, columnInfo.getStatement()); assertTrue( columnInfo.next() ); int dataType = columnInfo.getInt( "DATA_TYPE" ); s.getJdbcCoordinator().getResourceRegistry().release( columnInfo, columnInfo.getStatement() ); assertEquals( columnName, JdbcTypeNameMapper.getTypeName( expectedJdbcTypeCode ), JdbcTypeNameMapper.getTypeName( dataType ) ); }
@Override public Statement getStatement() throws SQLException { return delegate.getStatement(); }
@Override public Statement getStatement() throws SQLException { return innerResultSet.getStatement(); }
@Override public Statement getStatement() throws SQLException { return innerResultSet.getStatement(); }
@Override public Statement getStatement() throws SQLException { return rs.getStatement(); }
public JDBCIterator(ResultSet rs) throws SQLException { this.rs = rs; this.next = rs.next(); // can't call rs.getStatement() after rs is closed, so must do it now this.stmt = rs.getStatement(); this.builder = new RecordBuilder(JDBCDataSource.this); }
@Override public void close() throws IOException { try { Statement st = rs.getStatement(); Connection conn = st.getConnection(); rs.close(); st.close(); conn.close(); } catch (SQLException e) { throw new IOException(e); } } }
public JDBCFeatureReader( ResultSet rs, Connection cx, int offset, JDBCFeatureSource featureSource, SimpleFeatureType featureType, Query query) throws SQLException { init(featureSource, featureType, query); this.cx = cx; this.st = rs.getStatement(); this.rs = rs; this.offset = offset; }
@Override public Statement resultSet_getStatement(ResultSetProxy resultSet) throws SQLException { if (this.pos < filterSize) { return nextFilter().resultSet_getStatement(this, resultSet); } return resultSet.getResultSetRaw().getStatement(); }
public static void deepCleanUp(ResultSet resultSet) { try { if (resultSet != null) { Statement statement = resultSet.getStatement(); Connection connection = statement.getConnection(); cleanUp(connection, statement, resultSet); } } catch (SQLException sqle) { if (_log.isWarnEnabled()) { _log.warn(sqle.getMessage()); } } }
private void closeRs() { Boolean closed = isRsClosed(); if (closed==null || !closed) { closeIt(log, ignore(rs::getStatement), closeConnection ? ignore(()->rs.getStatement().getConnection()) : null); } }