Java Code Examples for java.sql.ResultSet#getBinaryStream()

/**
 *
 * @param Id
 * @param Ver
 * @return
 * @throws PDException
 */
protected InputStream Retrieve(String Id, String Ver, Record Rec) throws PDException
{
VerifyId(Id);
try {
String SQL = "SELECT PDCONT FROM "+getTable()+" where PDId='"+Id+"' and PDVersion='"+Ver+"'";
PreparedStatement BlobStmt = con.prepareStatement(SQL);
ResultSet resultSet = BlobStmt.executeQuery();
while (resultSet.next())
    {
    return (resultSet.getBinaryStream(1));
    }
PDException.GenPDException("Inexistent_content", Id+"/"+Ver);
} catch (Exception ex)
    {
    PDException.GenPDException("Error_retrieving_content", ex.getLocalizedMessage());
    }
return(null);
}
 

/**
 * <p>
 * This method should be overridden by any delegate subclasses that need
 * special handling for BLOBs. The default implementation uses standard
 * JDBC <code>java.sql.Blob</code> operations.
 * </p>
 * 
 * @param rs
 *          the result set, already queued to the correct row
 * @param colName
 *          the column name for the BLOB
 * @return the deserialized Object from the ResultSet BLOB
 * @throws ClassNotFoundException
 *           if a class found during deserialization cannot be found
 * @throws IOException
 *           if deserialization causes an error
 */
protected Object getObjectFromBlob(ResultSet rs, String colName)
    throws ClassNotFoundException, IOException, SQLException {
    InputStream binaryInput = rs.getBinaryStream(colName);

    if(binaryInput == null || binaryInput.available() == 0) {
        return null;
    }
    
    Object obj = null;
    
    ObjectInputStream in = new ObjectInputStream(binaryInput);
    try {
        obj = in.readObject();
    } finally {
        in.close();
    }

    return obj;
}
 

public byte[] getBytes() {
    try {
        final DataSource ds = (DataSource) new InitialContext().lookup("java:comp/env/jdbc/DefaultDatabase");
        final Connection c = ds.getConnection();
        final PreparedStatement ps = c.prepareStatement("SELECT blob_column FROM storage WHERE id = ?");
        ps.setInt(1, (Integer) ctx.getPrimaryKey());
        final ResultSet rs = ps.executeQuery();
        rs.next();
        final InputStream is = rs.getBinaryStream(1);
        final ByteArrayOutputStream os = new ByteArrayOutputStream();
        final byte[] buffer = new byte[1024];
        int count;
        while ((count = is.read(buffer)) > 0) {
            os.write(buffer, 0, count);
        }
        is.close();
        os.close();
        rs.close();
        ps.close();
        c.close();
        return os.toByteArray();
    } catch (final Exception e) {
        throw new EJBException(e);
    }
}
 

/**
 * Test that the client throws an exception when an exception is thrown on
 * the server side when streaming from the database.
 */
public void testInterruptedReadOfLob()
        throws IOException, SQLException {
    PreparedStatement fetchLobSt = prepareStatement(
            "select TEST_COL from TEST_TABLE");
    ResultSet rs = fetchLobSt.executeQuery();
    try {
        rs.next();
        InputStream is = rs.getBinaryStream(1);
        // Read the stream.
        int c;
        while ( (c = is.read() ) > -1) {}
        fail("Reading stream should have raised exception.");
    } catch (SQLException sqle) {
        assertSQLState("58009", sqle);
    }
    rs.close();
    fetchLobSt.close();
}
 

private static void checkBlob(ResultSet rs, int index, byte[] expected, int key) {
    try {
        byte[] actual = rs.getBytes(index);
        Assert.assertArrayEquals(expected, actual);

        if (expected != null) {
            DataInputStream dataInputStream = new DataInputStream(rs.getBinaryStream(index));
            byte[] actualFromStream = new byte[actual.length];
            dataInputStream.readFully(actualFromStream);
            Assert.assertArrayEquals("error at key " + key, expected, actualFromStream);

            Blob blob = rs.getBlob(index);
            assertEquals("error at key " + key, blob.length(), actual.length);

            DataInputStream dataInputStream2 = new DataInputStream(blob.getBinaryStream());
            byte[] actualFromStream2 = new byte[actual.length];
            dataInputStream2.readFully(actualFromStream2);
            Assert.assertArrayEquals("error at key " + key, expected, actualFromStream2);
        }

        byte[] object = (byte[]) rs.getObject(index);
        Assert.assertArrayEquals((byte[]) expected, object);
    } catch (SQLException | IOException e) {
        throw new RuntimeException(e);
    }
}
 

/**
 * <p>
 * This method should be overridden by any delegate subclasses that need
 * special handling for BLOBs. The default implementation uses standard
 * JDBC <code>java.sql.Blob</code> operations.
 * </p>
 * 
 * @param rs
 *          the result set, already queued to the correct row
 * @param colName
 *          the column name for the BLOB
 * @return the deserialized Object from the ResultSet BLOB
 * @throws ClassNotFoundException
 *           if a class found during deserialization cannot be found
 * @throws IOException
 *           if deserialization causes an error
 */
@Override           
protected Object getObjectFromBlob(ResultSet rs, String colName)
    throws ClassNotFoundException, IOException, SQLException {
    InputStream binaryInput = rs.getBinaryStream(colName);

    if(binaryInput == null || binaryInput.available() == 0) {
        return null;
    }
    
    Object obj = null;
    
    ObjectInputStream in = new ObjectInputStream(binaryInput);
    try {
        obj = in.readObject();
    } finally {
        in.close();
    }

    return obj;
}
 

static void get_using_binary_stream(ResultSet rs, int col_no) throws Exception{
	System.out.println("getBinaryStream(" + col_no + ")");
      int no_bytes_read = 0;
      InputStream rsbin = rs.getBinaryStream(col_no);
      byte [] bytearray = new byte[200];
int count = 0;
      while((no_bytes_read=rsbin.read(bytearray)) != -1)
      {
	count = printbytearray(bytearray, no_bytes_read, count);
      }
System.out.println("");
  }
 

@Override
@Nullable
public InputStream getBlobAsBinaryStream(ResultSet rs, int columnIndex) throws SQLException {
	logger.debug("Returning BLOB as binary stream");
	if (this.wrapAsLob) {
		Blob blob = rs.getBlob(columnIndex);
		return blob.getBinaryStream();
	}
	else {
		return rs.getBinaryStream(columnIndex);
	}
}
 

public Collection<DestinationSequence> getDestinationSequences(String endpointIdentifier) {
    if (LOG.isLoggable(Level.FINE)) {
        LOG.info("Getting destination sequences for endpoint: " + endpointIdentifier);
    }
    Connection con = verifyConnection();
    PreparedStatement stmt = null;
    SQLException conex = null;
    Collection<DestinationSequence> seqs = new ArrayList<>();
    ResultSet res = null;
    try {
        stmt = getStatement(con, SELECT_DEST_SEQUENCES_STMT_STR);

        stmt.setString(1, endpointIdentifier);
        res = stmt.executeQuery();
        while (res.next()) {
            Identifier sid = new Identifier();
            sid.setValue(res.getString(1));
            EndpointReferenceType acksTo = RMUtils.createReference(res.getString(2));
            long lm = res.getLong(3);
            ProtocolVariation pv = decodeProtocolVersion(res.getString(4));
            boolean t = res.getBoolean(5);
            InputStream is = res.getBinaryStream(6);
            SequenceAcknowledgement ack = null;
            if (null != is) {
                ack = PersistenceUtils.getInstance()
                    .deserialiseAcknowledgment(is);
            }
            DestinationSequence seq = new DestinationSequence(sid, acksTo, lm, t, ack, pv);
            seqs.add(seq);
        }
    } catch (SQLException ex) {
        conex = ex;
        LOG.log(Level.WARNING, new Message("SELECT_DEST_SEQ_FAILED_MSG", LOG).toString(), ex);
    } finally {
        releaseResources(stmt, res);
        updateConnectionState(con, conex);
    }
    return seqs;
}
 

@Override
protected Object getJobDataFromBlob(ResultSet rs, String colName)
    throws ClassNotFoundException, IOException, SQLException {
    
    if (canUseProperties()) {
        InputStream binaryInput = rs.getBinaryStream(colName);
        return binaryInput;
    }

    return getObjectFromBlob(rs, colName);
}
 

/**
 * This methods tests the ResultSet interface method
 * updateBinaryStream
 *
 * @throws SQLException if some error occurs while calling the method
 */

public void testUpdateBinaryStreamStringParameterName()
throws Exception {
    //Byte array in which the returned bytes from
    //the Database after the update are stored. This
    //array is then checked to determine if it
    //has the same elements of the Byte array used for
    //the update operation

    byte[] bytes_ret = new byte[10];

    //Input Stream inserted initially
    InputStream is = new java.io.ByteArrayInputStream(BYTES1);

    //InputStream that is used for update
    InputStream is_for_update = new
            java.io.ByteArrayInputStream(BYTES2);

    //Prepared Statement used to insert the data
    PreparedStatement ps_sb = prep("dLongBit");
    ps_sb.setInt(1, key);
    ps_sb.setBinaryStream(2,is,BYTES1.length);
    ps_sb.executeUpdate();
    ps_sb.close();

    //Update operation
    //Update operation
    //use a different ResultSet variable so that the
    //other tests can go on unimpacted

    ResultSet rs1 = fetchUpd("dLongBit", key);
    rs1.next();
    rs1.updateBinaryStream("dLongBit",is_for_update,(int)BYTES2.length);
    rs1.updateRow();
    rs1.close();

    //Query to see whether the data that has been updated
    //using the updateBinaryStream method is the same
    //data that we expected

    rs1 = fetch("dLongBit", key);
    rs1.next();
    InputStream is_ret = rs1.getBinaryStream(1);

    is_ret.read(bytes_ret);
    is_ret.close();

    for(int i=0;i<BYTES2.length;i++) {
        assertEquals("Error in updateBinaryStream",BYTES2[i],bytes_ret[i]);
    }
    rs1.close();
}
 

/**
 * This methods tests the ResultSet interface method
 * updateBinaryStream
 *
 * @throws SQLException if some error occurs while calling the method
 */

public void testUpdateBinaryStream()
throws Exception {
    //Byte array in which the returned bytes from
    //the Database after the update are stored. This
    //array is then checked to determine if it
    //has the same elements of the Byte array used for
    //the update operation

    byte[] bytes_ret = new byte[10];

    //Input Stream inserted initially
    InputStream is = new java.io.ByteArrayInputStream(BYTES1);

    //InputStream that is used for update
    InputStream is_for_update = new
            java.io.ByteArrayInputStream(BYTES2);

    //Prepared Statement used to insert the data
    PreparedStatement ps_sb = prep("dLongBit");
    ps_sb.setInt(1,key);
    ps_sb.setBinaryStream(2,is,BYTES1.length);
    ps_sb.executeUpdate();
    ps_sb.close();

    //Update operation
    //use a different ResultSet variable so that the
    //other tests can go on unimpacted

    ResultSet rs1 = fetchUpd("dLongBit", key);
    rs1.next();
    rs1.updateBinaryStream(1,is_for_update,(int)BYTES2.length);
    rs1.updateRow();
    rs1.close();

    //Query to see whether the data that has been updated
    //using the updateBinaryStream method is the same
    //data that we expected

    rs1 = fetch("dLongBit", key);
    rs1.next();
    InputStream is_ret = rs1.getBinaryStream(1);

    is_ret.read(bytes_ret);
    is_ret.close();

    for(int i=0;i<BYTES2.length;i++) {
        assertEquals("Error in updateBinaryStream",BYTES2[i],bytes_ret[i]);
    }
    rs1.close();
}
 

@Override
public InputStream getStream( String request ) throws Exception
{
	Connection conn = connection;
	// If no given connection, create one from the DataSource.
	if (connection == null)
	{
		conn = dataSource.getConnection();
	}

	InputStream input = null;
	try
	{
		// Prepares the query for execution.
		PreparedStatement statement = conn.prepareStatement( query );
		try
		{
			// Places the request string in the query.
			statement.setString( 1, request );

			// Executes the query.
			ResultSet results = statement.executeQuery();
			try
			{
				// If results were returned, read them in as a binary stream.
				if (results.next())
				{
					input = results.getBinaryStream( 1 );
				}
			}
			finally
			{
				results.close();
			}
		}
		finally
		{
			statement.close();
		}
	}
	finally
	{
		// If a connection was created from the DataSource make sure to
		// close it.
		if (connection == null)
		{
			conn.close();
		}
	}

	return input;
}
 

/** convert resultset data for the current row to string array. 
    * If large objects are being exported to an external file, 
    * then write the lob  data into the external file and store 
    * the lob data location  in the string array for that column.
    * @param rs   resultset that contains the data to export.
    * @param isLargeBinary  boolean array, whose elements will
    *                      be true, if the column type is blob/or 
    *                      other large binary type, otherwise false. 
    * @param isLargeChar   boolean array, whose elements will
    *                      be true, if the column type is clob/ 
    *                      other large char type, otherwise false. 
    * @return A string array of the row data to write to export file.
    * @exception  Exception  if any errors during conversion. 
    */
   private String[] getOneRowAtATime(ResultSet rs, 
                                     boolean[] isLargeBinary, 
                                     boolean[] isLargeChar) 
       throws Exception 
{
   int columnCount = exportResultSetForObject.getColumnCount();

ResultSetMetaData rsm=rs.getMetaData();
   if (rs.next()){
      String[] rowObjects = new String[columnCount];
      for (int colNum = 0; colNum < columnCount; colNum++) {
          if (lobsInExtFile && 
              (isLargeChar[colNum] || isLargeBinary[colNum])) 
          {	
              String LobExtLocation;
              if (isLargeBinary[colNum]) {

                  // get input stream that has the column value as a 
                  // stream of uninterpreted bytes; if the value is SQL NULL, 
                  // the return value  is null
                  InputStream is = rs.getBinaryStream(colNum + 1);
                  LobExtLocation = 
                      exportWriteData.writeBinaryColumnToExternalFile(is);
              } else {
                  // It is clob data, get character stream that has 
                  // the column value. if the value is SQL NULL, the 
                  // return value  is null
                  Reader ir = rs.getCharacterStream(colNum + 1);
                  LobExtLocation  = 
                      exportWriteData.writeCharColumnToExternalFile(ir);
              }
              rowObjects[colNum]= LobExtLocation;

              // when lob data is written to the main export file, binary 
              // data is written in hex format. getString() call on binary 
              // columns returns the data in hex format, no special handling 
              // required. In case of large char tpe like Clob, data 
              // is written to main export file  similar to other char types. 
              
              // TODO : handling of Nulls. 
          }
	   else {
              String columnValue;
              int jdbcColumnNumber = colNum + 1;
              
              if ( rsm.getColumnType( jdbcColumnNumber ) == java.sql.Types.JAVA_OBJECT )
              { columnValue = stringifyObject( rs.getObject( jdbcColumnNumber ) ); }
              else { columnValue = rs.getString( jdbcColumnNumber ); }
              
		   rowObjects[colNum] = columnValue;
          }
      }
      return rowObjects;
   }
   rs.close();
exportResultSetForObject.close();
   return null;
 }
 

private static void testReadOfLob() 
throws SQLException,
       IOException,
       IllegalAccessException,
       ClassNotFoundException,
       InstantiationException
   {

Connection conn = 
    getConnection();

conn.setAutoCommit(false);

PreparedStatement insertLobSt = 
    conn.prepareStatement("insert into TEST_TABLE( TEST_COL ) values(?)");
insertLobSt.setBinaryStream(1, 
			    createOriginalDataInputStream( 65536 ), 
			    65536 );
insertLobSt.executeUpdate();
insertLobSt.close();

conn.commit();

PreparedStatement st = conn.prepareStatement("select TEST_COL from TEST_TABLE");
ResultSet rs = st.executeQuery();

rs.next();

InputStream is = rs.getBinaryStream(1);

int c;
while( ( c = is.read() ) > -1 ){
    
    System.out.print(c);
    System.out.print(",");
    
    if( ( (c + 1) % 256 ) == 0 )
	System.out.println();

}

is.close();

rs.close();
st.close();

conn.commit();
conn.close();

System.out.println();

   }
 

/**
 * Delegates to {@link ResultSet#getObject(int, Class)} without throwing a {@link AbstractMethodError}.
 * <p>
 * If the JDBC driver does not implement {@link ResultSet#getObject(int, Class)}, then return 0.
 * </p>
 *
 * @param <T>
 *            See {@link ResultSet#getObject(int, Class)}
 * @param resultSet
 *            See {@link ResultSet#getObject(int, Class)}
 * @param columnIndex
 *            See {@link ResultSet#getObject(int, Class)}
 * @param type
 *            See {@link ResultSet#getObject(int, Class)}
 * @return See {@link ResultSet#getObject(int, Class)}
 * @throws SQLException
 *             See {@link ResultSet#getObject(int, Class)}
 * @see ResultSet#getObject(int, Class)
 */
@SuppressWarnings("unchecked")
public static <T> T getObject(final ResultSet resultSet, final int columnIndex, final Class<T> type)
        throws SQLException {
    try {
        return resultSet.getObject(columnIndex, type);
    } catch (final AbstractMethodError e) {
        if (type == String.class) {
            return (T) resultSet.getString(columnIndex);
        }
        // Numbers
        if (type == Integer.class) {
            return (T) Integer.valueOf(resultSet.getInt(columnIndex));
        }
        if (type == Long.class) {
            return (T) Long.valueOf(resultSet.getLong(columnIndex));
        }
        if (type == Double.class) {
            return (T) Double.valueOf(resultSet.getDouble(columnIndex));
        }
        if (type == Float.class) {
            return (T) Float.valueOf(resultSet.getFloat(columnIndex));
        }
        if (type == Short.class) {
            return (T) Short.valueOf(resultSet.getShort(columnIndex));
        }
        if (type == BigDecimal.class) {
            return (T) resultSet.getBigDecimal(columnIndex);
        }
        if (type == Byte.class) {
            return (T) Byte.valueOf(resultSet.getByte(columnIndex));
        }
        // Dates
        if (type == Date.class) {
            return (T) resultSet.getDate(columnIndex);
        }
        if (type == Time.class) {
            return (T) resultSet.getTime(columnIndex);
        }
        if (type == Timestamp.class) {
            return (T) resultSet.getTimestamp(columnIndex);
        }
        // Streams
        if (type == InputStream.class) {
            return (T) resultSet.getBinaryStream(columnIndex);
        }
        if (type == Reader.class) {
            return (T) resultSet.getCharacterStream(columnIndex);
        }
        // Other
        if (type == Object.class) {
            return (T) resultSet.getObject(columnIndex);
        }
        if (type == Boolean.class) {
            return (T) Boolean.valueOf(resultSet.getBoolean(columnIndex));
        }
        if (type == Array.class) {
            return (T) resultSet.getArray(columnIndex);
        }
        if (type == Blob.class) {
            return (T) resultSet.getBlob(columnIndex);
        }
        if (type == Clob.class) {
            return (T) resultSet.getClob(columnIndex);
        }
        if (type == Ref.class) {
            return (T) resultSet.getRef(columnIndex);
        }
        if (type == RowId.class) {
            return (T) resultSet.getRowId(columnIndex);
        }
        if (type == SQLXML.class) {
            return (T) resultSet.getSQLXML(columnIndex);
        }
        if (type == URL.class) {
            return (T) resultSet.getURL(columnIndex);
        }
        throw new SQLFeatureNotSupportedException(
                String.format("resultSet=%s, columnIndex=%,d, type=%s", resultSet, Integer.valueOf(columnIndex), type));
    }
}
 

private static void testReadOfLob() 
throws SQLException,
       IOException,
       IllegalAccessException,
       ClassNotFoundException,
       InstantiationException
   {

Connection conn = 
    getConnection();

conn.setAutoCommit(false);

PreparedStatement insertLobSt = 
    conn.prepareStatement("insert into TEST_TABLE( TEST_COL ) values(?)");
insertLobSt.setBinaryStream(1, 
			    createOriginalDataInputStream( 65536 ), 
			    65536 );
insertLobSt.executeUpdate();
insertLobSt.close();

conn.commit();

PreparedStatement st = conn.prepareStatement("select TEST_COL from TEST_TABLE");
ResultSet rs = st.executeQuery();

rs.next();

InputStream is = rs.getBinaryStream(1);

int c;
while( ( c = is.read() ) > -1 ){
    
    System.out.print(c);
    System.out.print(",");
    
    if( ( (c + 1) % 256 ) == 0 )
	System.out.println();

}

is.close();

rs.close();
st.close();

conn.commit();
conn.close();

System.out.println();

   }
 

@Override
public InputStream getBinaryStreamFromByteArray(ResultSet rs, String columnName) throws SQLException {
    return rs.getBinaryStream(columnName);
}
 

private static String getValues(final ResultSet rs, final String columnName, final Integer columnType)
        throws SQLException {

    String res = null;

    try {
        switch (columnType) {
            case Types.BINARY:
            case Types.VARBINARY:
            case Types.LONGVARBINARY:
                final InputStream is = rs.getBinaryStream(columnName);
                if (is != null) {
                    res = DatatypeConverter.printHexBinary(IOUtils.toByteArray(is));
                }
                break;

            case Types.BLOB:
                final Blob blob = rs.getBlob(columnName);
                if (blob != null) {
                    res = DatatypeConverter.printHexBinary(IOUtils.toByteArray(blob.getBinaryStream()));
                }
                break;

            case Types.BIT:
            case Types.BOOLEAN:
                if (rs.getBoolean(columnName)) {
                    res = "1";
                } else {
                    res = "0";
                }
                break;

            case Types.DATE:
            case Types.TIME:
            case Types.TIMESTAMP:
                final Timestamp timestamp = rs.getTimestamp(columnName);
                if (timestamp != null) {
                    res = FormatUtils.format(new Date(timestamp.getTime()));
                }
                break;

            default:
                res = rs.getString(columnName);
        }
    } catch (IOException e) {
        LOG.error("Error retrieving hexadecimal string", e);
    }

    return res;
}
 

/**
 * Delegates to {@link ResultSet#getObject(int, Class)} without throwing an {@link AbstractMethodError}.
 * <p>
 * If the JDBC driver does not implement {@link ResultSet#getObject(int, Class)}, then return 0.
 * </p>
 *
 * @param <T>
 *            See {@link ResultSet#getObject(int, Class)}
 * @param resultSet
 *            See {@link ResultSet#getObject(int, Class)}
 * @param columnIndex
 *            See {@link ResultSet#getObject(int, Class)}
 * @param type
 *            See {@link ResultSet#getObject(int, Class)}
 * @return See {@link ResultSet#getObject(int, Class)}
 * @throws SQLException
 *             See {@link ResultSet#getObject(int, Class)}
 * @see ResultSet#getObject(int, Class)
 */
@SuppressWarnings("unchecked")
public static <T> T getObject(final ResultSet resultSet, final int columnIndex, final Class<T> type)
        throws SQLException {
    try {
        return resultSet.getObject(columnIndex, type);
    } catch (final AbstractMethodError e) {
        if (type == String.class) {
            return (T) resultSet.getString(columnIndex);
        }
        // Numbers
        if (type == Integer.class) {
            return (T) Integer.valueOf(resultSet.getInt(columnIndex));
        }
        if (type == Long.class) {
            return (T) Long.valueOf(resultSet.getLong(columnIndex));
        }
        if (type == Double.class) {
            return (T) Double.valueOf(resultSet.getDouble(columnIndex));
        }
        if (type == Float.class) {
            return (T) Float.valueOf(resultSet.getFloat(columnIndex));
        }
        if (type == Short.class) {
            return (T) Short.valueOf(resultSet.getShort(columnIndex));
        }
        if (type == BigDecimal.class) {
            return (T) resultSet.getBigDecimal(columnIndex);
        }
        if (type == Byte.class) {
            return (T) Byte.valueOf(resultSet.getByte(columnIndex));
        }
        // Dates
        if (type == Date.class) {
            return (T) resultSet.getDate(columnIndex);
        }
        if (type == Time.class) {
            return (T) resultSet.getTime(columnIndex);
        }
        if (type == Timestamp.class) {
            return (T) resultSet.getTimestamp(columnIndex);
        }
        // Streams
        if (type == InputStream.class) {
            return (T) resultSet.getBinaryStream(columnIndex);
        }
        if (type == Reader.class) {
            return (T) resultSet.getCharacterStream(columnIndex);
        }
        // Other
        if (type == Object.class) {
            return (T) resultSet.getObject(columnIndex);
        }
        if (type == Boolean.class) {
            return (T) Boolean.valueOf(resultSet.getBoolean(columnIndex));
        }
        if (type == Array.class) {
            return (T) resultSet.getArray(columnIndex);
        }
        if (type == Blob.class) {
            return (T) resultSet.getBlob(columnIndex);
        }
        if (type == Clob.class) {
            return (T) resultSet.getClob(columnIndex);
        }
        if (type == Ref.class) {
            return (T) resultSet.getRef(columnIndex);
        }
        if (type == RowId.class) {
            return (T) resultSet.getRowId(columnIndex);
        }
        if (type == SQLXML.class) {
            return (T) resultSet.getSQLXML(columnIndex);
        }
        if (type == URL.class) {
            return (T) resultSet.getURL(columnIndex);
        }
        throw new SQLFeatureNotSupportedException(
                String.format("resultSet=%s, columnIndex=%,d, type=%s", resultSet, columnIndex, type));
    }
}