Example usage for java.sql Types OTHER

List of usage examples for java.sql Types OTHER

  1. HOME
  2. Java
  3. java
  4. java.sql.*
  5. Types
  6. OTHER

Introduction

In this page you can find the example usage for java.sql Types OTHER.

Prototype

int OTHER

To view the source code for java.sql Types OTHER.

Click Source Link

Document

The constant in the Java programming language that indicates that the SQL type is database-specific and gets mapped to a Java object that can be accessed via the methods getObject and setObject.

Usage

From source file:org.apache.openjpa.jdbc.sql.PostgresDictionary.java

/**
 * Handle XML and bytea/oid columns in a PostgreSQL way.
 *///from w ww .j a  v  a  2 s.  c  o m
@Override
public void setNull(PreparedStatement stmnt, int idx, int colType, Column col) throws SQLException {
    if (col != null && col.isXML()) {
        stmnt.setNull(idx, Types.OTHER);
        return;
    }

    // OPENJPA-308
    if (colType == Types.BLOB)
        colType = Types.BINARY;
    stmnt.setNull(idx, colType);
}

From source file:org.netflux.core.FieldMetadata.java

/**
 * Returns a string representation of the provided type.
 * /*from w  w  w.  ja  v a 2 s .c o  m*/
 * @param type the type from {@link Types} to transform to a string.
 * @return a string representation of the provided type.
 */
public static String typeToString(int type) {
    switch (type) {
    case Types.ARRAY:
        return "ARRAY";

    case Types.BIGINT:
        return "BIGINT";

    case Types.BINARY:
        return "BINARY";

    case Types.BIT:
        return "BIT";

    case Types.BLOB:
        return "BLOB";

    case Types.BOOLEAN:
        return "BOOLEAN";

    case Types.CHAR:
        return "CHAR";

    case Types.CLOB:
        return "CLOB";

    case Types.DATALINK:
        return "DATALINK";

    case Types.DATE:
        return "DATE";

    case Types.DECIMAL:
        return "DECIMAL";

    case Types.DISTINCT:
        return "DISTINCT";

    case Types.DOUBLE:
        return "DOUBLE";

    case Types.FLOAT:
        return "FLOAT";

    case Types.INTEGER:
        return "INTEGER";

    case Types.JAVA_OBJECT:
        return "JAVA_OBJECT";

    case Types.LONGVARBINARY:
        return "LONGVARBINARY";

    case Types.LONGVARCHAR:
        return "LONGVARCHAR";

    case Types.NULL:
        return "NULL";

    case Types.NUMERIC:
        return "NUMERIC";

    case Types.OTHER:
        return "OTHER";

    case Types.REAL:
        return "REAL";

    case Types.REF:
        return "REF";

    case Types.SMALLINT:
        return "SMALLINT";

    case Types.STRUCT:
        return "STRUCT";

    case Types.TIME:
        return "TIME";

    case Types.TIMESTAMP:
        return "TIMESTAMP";

    case Types.TINYINT:
        return "TINYINT";

    case Types.VARBINARY:
        return "VARBINARY";

    case Types.VARCHAR:
        return "VARCHAR";

    default:
        return "*unsupported type*";
    }
}

From source file:com.squid.core.domain.operators.ExtendedType.java

public static int FromTypeName(String SQLName) {
    if (SQLName.equals("ARRAY")) {
        return Types.ARRAY;
    }//w  ww .ja v  a  2 s .com
    if (SQLName.equals("INTEGER")) {
        return Types.INTEGER;
    }
    if (SQLName.equals("BINARY")) {
        return Types.BINARY;
    }
    if (SQLName.equals("BIT")) {
        return Types.BIT;
    }
    if (SQLName.equals("BLOB")) {
        return Types.BLOB;
    }
    if (SQLName.equals("BOOLEAN")) {
        return Types.BOOLEAN;
    }
    if (SQLName.equals("CHAR")) {
        return Types.CHAR;
    }
    if (SQLName.equals("CLOB")) {
        return Types.CLOB;
    }
    if (SQLName.equals("DATALINK")) {
        return Types.DATALINK;
    }
    if (SQLName.equals("DATE")) {
        return Types.DATE;
    }
    if (SQLName.equals("DECIMAL")) {
        return Types.DECIMAL;
    }
    if (SQLName.equals("DOUBLE")) {
        return Types.DOUBLE;
    }
    if (SQLName.equals("FLOAT")) {
        return Types.FLOAT;
    }
    if (SQLName.equals("JAVA_OBJECT")) {
        return Types.JAVA_OBJECT;
    }
    if (SQLName.equals("LONGNVARCHAR")) {
        return Types.LONGNVARCHAR;
    }
    if (SQLName.equals("LONGVARBINARY")) {
        return Types.LONGVARBINARY;
    }
    if (SQLName.equals("NCHAR")) {
        return Types.NCHAR;
    }
    if (SQLName.equals("NCLOB")) {
        return Types.NCLOB;
    }
    if (SQLName.equals("UNDEFINED")) {
        return Types.OTHER;
    }
    if (SQLName.equals("NUMERIC")) {
        return Types.NUMERIC;
    }
    if (SQLName.equals("NVARCHAR")) {
        return Types.NVARCHAR;
    }
    if (SQLName.equals("REAL")) {
        return Types.REAL;
    }
    if (SQLName.equals("REF")) {
        return Types.REF;
    }
    if (SQLName.equals("ROWID")) {
        return Types.ROWID;
    }
    if (SQLName.equals("SMALLINT")) {
        return Types.SMALLINT;
    }
    if (SQLName.equals("SQLXML")) {
        return Types.SQLXML;
    }
    if (SQLName.equals("STRUCT")) {
        return Types.STRUCT;
    }
    if (SQLName.equals("TIME")) {
        return Types.TIME;
    }
    if (SQLName.equals("TIMESTAMP")) {
        return Types.TIMESTAMP;
    }
    if (SQLName.equals("TINYINT")) {
        return Types.TINYINT;
    }
    if (SQLName.equals("VARCHAR")) {
        return Types.VARCHAR;
    }
    if (SQLName.equals("VARBINARY")) {
        return Types.VARBINARY;
    }
    return Types.OTHER;
}

From source file:es.juntadeandalucia.panelGestion.persistencia.dao.impl.RemoteDataBaseDAOImpl.java

private String getSQLInsertFromColumns(String schemaTableName, List<ColumnVO> columns, Integer srid) {
    StringBuilder sqlBuilder = new StringBuilder();
    StringBuilder columnNames = new StringBuilder();
    StringBuilder columnValues = new StringBuilder();

    // escapes column names and column values
    boolean hasX = false, hasY = false;
    columnNames.append("(");
    columnValues.append("(");
    for (int i = 0; i < columns.size(); i++) {
        ColumnVO column = columns.get(i);
        String columnName = column.getNameOnTable();
        if (StringUtils.isEmpty(columnName)) {
            columnName = column.getText();
        }/*w w w  .  j  a v  a  2s  .  c  o  m*/
        if (StringUtils.isEmpty(columnName)) {
            throw new IllegalArgumentException("Nombre de la columna vaco");
        } else if (!Utils.isValidName(columnName)) {
            throw new IllegalArgumentException("Nombre de la columna no vlido: " + columnName);
        } else {
            if (column.isCoordinateX()) {
                columnValues.append("?");
                columnNames.append(columnName);
                hasX = true;
            } else if (column.isCoordinateY()) {
                hasY = true;
                columnValues.append("?");
                columnNames.append(columnName);
            } else if ((column.getSqlType() == Types.OTHER) || column.isFromCoordinates()) {
                // geometry type
                columnNames.append(columnName);
                columnValues.append("ST_GeometryFromText(?, ").append(srid).append(")");
            } else {
                columnValues.append("?");
                columnNames.append(columnName);
            }

            if (i < (columns.size() - 1)) {
                columnNames.append(", ");
                columnValues.append(", ");
            }
        }
    }
    if (hasX && hasY) {
        columnNames.append(", ");
        columnValues.append(", ");
        columnValues.append("ST_GeometryFromText(?, ").append(srid).append(")");
        columnNames.append(geomFieldName);
    }
    columnNames.append(")");
    columnValues.append(")");

    sqlBuilder.append("INSERT INTO ").append(schemaTableName).append(" ").append(columnNames).append(" VALUES ")
            .append(columnValues).append(";");

    return sqlBuilder.toString();
}

From source file:org.nuxeo.ecm.core.storage.sql.jdbc.dialect.DialectOracle.java

@Override
public void setToPreparedStatement(PreparedStatement ps, int index, Serializable value, Column column)
        throws SQLException {
    switch (column.getJdbcType()) {
    case Types.VARCHAR:
    case Types.CLOB:
        setToPreparedStatementString(ps, index, value, column);
        return;// w  w w . j  a  v a  2s.  c o  m
    case Types.BIT:
        ps.setBoolean(index, ((Boolean) value).booleanValue());
        return;
    case Types.TINYINT:
    case Types.SMALLINT:
        ps.setInt(index, ((Long) value).intValue());
        return;
    case Types.INTEGER:
    case Types.BIGINT:
        ps.setLong(index, ((Number) value).longValue());
        return;
    case Types.DOUBLE:
        ps.setDouble(index, ((Double) value).doubleValue());
        return;
    case Types.TIMESTAMP:
        setToPreparedStatementTimestamp(ps, index, value, column);
        return;
    case Types.OTHER:
        ColumnType type = column.getType();
        if (type.isId()) {
            setId(ps, index, value);
            return;
        } else if (type == ColumnType.FTSTORED) {
            ps.setString(index, (String) value);
            return;
        }
        throw new SQLException("Unhandled type: " + column.getType());
    default:
        throw new SQLException("Unhandled JDBC type: " + column.getJdbcType());
    }
}

From source file:org.apache.cassandra.cql.jdbc.HandleObjects.java

public static final ByteBuffer makeBytes(Object object, int baseType, int scaleOrLength) throws SQLException {
    Class<? extends Object> objectClass = object.getClass();
    boolean isCollection = (Collection.class.isAssignableFrom(objectClass));
    int targetSqlType = isCollection ? Types.OTHER : baseType;
    // Type check first
    switch (targetSqlType) {
    case Types.TINYINT:
        // Only Numeric classes, Strings and Booleans are supported for transformation to TINYINT
        if (!(objectClass == String.class || objectClass == Boolean.class
                || Number.class.isAssignableFrom(object.getClass())))
            throw makeBadMapping(objectClass, STR_BOOL_NUMERIC, "TINYINT");
        break;/* ww  w .j  a va  2 s .  c  o  m*/

    case Types.SMALLINT:
        // Only Numeric classes, Strings and Booleans are supported for transformation to SMALLINT
        if (!(objectClass == String.class || objectClass == Boolean.class
                || Number.class.isAssignableFrom(object.getClass())))
            throw makeBadMapping(objectClass, STR_BOOL_NUMERIC, "SMALLINT");
        break;

    case Types.INTEGER:
        // Only Numeric classes, Strings and Booleans are supported for transformation to INTEGER
        if (!(objectClass == String.class || objectClass == Boolean.class
                || Number.class.isAssignableFrom(object.getClass())))
            throw makeBadMapping(objectClass, STR_BOOL_NUMERIC, "INTEGER");
        break;

    case Types.BIGINT:
        // Only Numeric classes, Strings and Booleans are supported for transformation to BIGINT
        if (!(objectClass == String.class || objectClass == Boolean.class
                || Number.class.isAssignableFrom(object.getClass())))
            throw makeBadMapping(objectClass, STR_BOOL_NUMERIC, "BIGINT");
        break;

    case Types.REAL:
    case Types.FLOAT:
    case Types.DOUBLE:
    case Types.DECIMAL:
        // Only Numeric classes Strings and Booleans are supported for transformation to REAL,FLOAT,DOUBLE,DECIMAL
        if (!(objectClass == String.class || objectClass == Boolean.class
                || Number.class.isAssignableFrom(object.getClass())))
            throw makeBadMapping(objectClass, STR_BOOL_NUMERIC, "the floating point types");
        break;

    case Types.NUMERIC:
        //NB This as a special case variation for Cassandra!! NUMERIC is transformed to java BigInteger (varint CQL type)
        //
        // Only Numeric classes Strings and Booleans are supported for transformation to NUMERIC
        if (!(objectClass == String.class || objectClass == Boolean.class
                || Number.class.isAssignableFrom(object.getClass())))
            throw makeBadMapping(objectClass, STR_BOOL_NUMERIC, "NUMERIC");
        break;

    case Types.BIT:
        // Only Numeric classes Strings and Booleans are supported for transformation to BIT
        if (!(objectClass == String.class || objectClass == Boolean.class
                || Number.class.isAssignableFrom(object.getClass())))
            throw makeBadMapping(objectClass, STR_BOOL_NUMERIC, "BIT");
        break;

    case Types.BOOLEAN:
        // Only Numeric classes Strings and Booleans are supported for transformation to BOOLEAN
        if (!(objectClass == String.class || objectClass == Boolean.class
                || Number.class.isAssignableFrom(object.getClass())))
            throw makeBadMapping(objectClass, STR_BOOL_NUMERIC, "BOOLEAN");
        break;

    case Types.CHAR:
    case Types.VARCHAR:
    case Types.LONGVARCHAR:
    case Types.NVARCHAR:
    case Types.LONGNVARCHAR:
        if (!objectClass.isAssignableFrom(String.class))
            throw makeBadMapping(objectClass, "String", "the various VARCHAR types");
        break;

    case Types.BINARY:
    case Types.VARBINARY:
    case Types.LONGVARBINARY:
        if (!(objectClass.isAssignableFrom(ByteBuffer.class) || objectClass.getSimpleName().equals("byte[]")))
            throw makeBadMapping(objectClass, "ByteBuffer or byte[]", "the BINARY Types");
        break;

    case Types.DATE:
        if (!(objectClass == String.class || objectClass == java.util.Date.class || objectClass == Date.class
                || objectClass == Timestamp.class))
            throw makeBadMapping(objectClass, "String, Date(java and sql) or Timestamp types", "DATE");
        break;

    case Types.TIME:
        if (!(objectClass == String.class || objectClass == java.util.Date.class || objectClass == Time.class
                || objectClass == Timestamp.class))
            throw makeBadMapping(objectClass, "String, Date (java), Time or Timestamp types", "TIME");
        break;

    case Types.TIMESTAMP:
        if (!(objectClass == String.class || objectClass == java.util.Date.class || objectClass == Date.class
                || objectClass == Timestamp.class))
            throw makeBadMapping(objectClass, "String, Date(java and sql) or Timestamp types", "TIMESTAMP");
        break;

    case Types.DATALINK:
        if (objectClass != URL.class)
            throw makeBadMapping(objectClass, "a URL type", "DATALINK");
        break;

    case Types.JAVA_OBJECT:
        break;

    case Types.OTHER:
        // Only Collection classes for transformation to OTHER
        if (!(List.class.isAssignableFrom(object.getClass()) || Set.class.isAssignableFrom(object.getClass())
                || Map.class.isAssignableFrom(object.getClass())))
            throw makeBadMapping(objectClass, STR_BOOL_NUMERIC, "OTHER");
        break;

    case Types.ROWID:
        if (objectClass != RowId.class)
            throw makeBadMapping(objectClass, "a RowId type", "ROWID");
        break;

    default:
        throw new SQLNonTransientException("Unsupported transformation to Jdbc Type: " + targetSqlType);
    }

    // see if we can map to an supported Type
    switch (targetSqlType) {
    case Types.BIT:
        BigInteger bitvalue = objectToBITorTINYINTorSMALLINTorNUMERIC(objectClass, object);
        assert bitvalue != null;
        return JdbcInteger.instance.decompose((bitvalue == BigInteger.ZERO) ? BigInteger.ZERO : BigInteger.ONE);

    case Types.TINYINT:
    case Types.SMALLINT:
    case Types.NUMERIC:
        BigInteger varint = objectToBITorTINYINTorSMALLINTorNUMERIC(objectClass, object);
        assert varint != null;
        return JdbcInteger.instance.decompose(varint);

    case Types.INTEGER:
        Integer value = objectToINTEGER(objectClass, object);
        assert value != null;
        return JdbcInt32.instance.decompose(value);

    case Types.BIGINT:
        Long longvalue = objectToBIGINT(objectClass, object);
        assert longvalue != null;
        return JdbcLong.instance.decompose(longvalue);

    case Types.BOOLEAN:
        Boolean bool = objectToBOOLEAN(objectClass, object);
        assert bool != null;
        return JdbcBoolean.instance.decompose(bool);

    case Types.CHAR:
    case Types.VARCHAR:
    case Types.LONGVARCHAR:
    case Types.NVARCHAR:
    case Types.LONGNVARCHAR:
        return ByteBufferUtil.bytes((String) object);

    case Types.BINARY:
    case Types.VARBINARY:
    case Types.LONGVARBINARY:
        if (objectClass.isAssignableFrom(ByteBuffer.class)) {
            return ((ByteBuffer) object);
        } else if (objectClass.getSimpleName().equals("byte[]")) {
            return ByteBuffer.wrap((byte[]) object);
        } else
            return null; // this should not happen

    case Types.DATE:
    case Types.TIME:
    case Types.TIMESTAMP:
        Long millis = objectToDATEorTIMEorTIMESTAMP(objectClass, object);
        assert millis != null;
        return JdbcLong.instance.decompose(millis);

    case Types.DATALINK:
        String urlAsString = ((URL) object).toExternalForm();
        return JdbcUTF8.instance.decompose(urlAsString);

    case Types.JAVA_OBJECT:
        return javaObject(object);

    case Types.OTHER:
        if (List.class.isAssignableFrom(objectClass)) {
            return handleAsList(objectClass, object);
        } else if (Set.class.isAssignableFrom(objectClass)) {
            return handleAsSet(objectClass, object);
        } else if (Map.class.isAssignableFrom(objectClass)) {
            return handleAsMap(objectClass, object);
        } else
            return null;

    case Types.ROWID:
        byte[] bytes = ((RowId) object).getBytes();
        return ByteBuffer.wrap(bytes);

    default:
        LOG.warn("Unhandled JDBC type: " + targetSqlType);
        return null;
    }
}

From source file:com.micromux.cassandra.jdbc.CollectionsTest.java

@Test
public void testUpdateMap() throws Exception {
    if (LOG.isDebugEnabled())
        LOG.debug("Test: 'testUpdateMap'\n");

    Statement statement = con.createStatement();

    // add some items to the set
    String update1 = "UPDATE testcollection SET M = M + {1.0: true, 3.0: false, 5.0: false} WHERE k = 1;";
    statement.executeUpdate(update1);/*ww  w .j a  v  a 2 s.  co  m*/

    ResultSet result = statement.executeQuery("SELECT * FROM testcollection WHERE k = 1;");
    result.next();

    assertEquals(1, result.getInt("k"));
    Object myObj = result.getObject("m");
    Map<Double, Boolean> myMap = (Map<Double, Boolean>) myObj;
    assertEquals(6, myMap.size());
    assertTrue(myMap.keySet().contains(5.0));

    if (LOG.isDebugEnabled())
        LOG.debug("m           = '{}'", myObj);

    // remove an item from the map
    String update2 = "DELETE M[6.0] FROM testcollection WHERE k = 1;";
    statement.executeUpdate(update2);

    result = statement.executeQuery("SELECT * FROM testcollection WHERE k = 1;");
    result.next();

    assertEquals(1, result.getInt("k"));

    myObj = result.getObject("m");
    myMap = (Map<Double, Boolean>) myObj;
    assertEquals(5, myMap.size());
    assertTrue(myMap.keySet().contains(5.0));
    assertFalse(myMap.keySet().contains(6.0));

    if (LOG.isDebugEnabled())
        LOG.debug("m           = '{}'", myObj);

    String update4 = "UPDATE testcollection SET M =  ? WHERE k = 1;";

    PreparedStatement prepared = con.prepareStatement(update4);
    Map<Double, Boolean> myNewMap = new LinkedHashMap<Double, Boolean>();
    myNewMap.put(10.0, false);
    myNewMap.put(12.0, true);
    prepared.setObject(1, myNewMap, Types.OTHER);
    prepared.execute();

    result = prepared.executeQuery("SELECT * FROM testcollection WHERE k = 1;");
    result.next();
    myObj = result.getObject("m");
    myMap = (Map<Double, Boolean>) myObj;

    if (LOG.isDebugEnabled())
        LOG.debug("m (prepared)= '{}'\n", myObj);
}

From source file:org.nuxeo.ecm.core.storage.sql.jdbc.dialect.DialectPostgreSQL.java

@Override
public void setToPreparedStatement(PreparedStatement ps, int index, Serializable value, Column column)
        throws SQLException {
    switch (column.getJdbcType()) {
    case Types.VARCHAR:
    case Types.CLOB:
        setToPreparedStatementString(ps, index, value, column);
        return;/*from w ww . j a  va 2s  .  c  o m*/
    case Types.BIT:
        ps.setBoolean(index, ((Boolean) value).booleanValue());
        return;
    case Types.SMALLINT:
        ps.setInt(index, ((Long) value).intValue());
        return;
    case Types.INTEGER:
    case Types.BIGINT:
        ps.setLong(index, ((Number) value).longValue());
        return;
    case Types.DOUBLE:
        ps.setDouble(index, ((Double) value).doubleValue());
        return;
    case Types.TIMESTAMP:
        ps.setTimestamp(index, getTimestampFromCalendar((Calendar) value));
        return;
    case Types.ARRAY:
        int jdbcBaseType = column.getJdbcBaseType();
        String jdbcBaseTypeName = column.getSqlBaseTypeString();
        if (jdbcBaseType == Types.TIMESTAMP) {
            value = getTimestampFromCalendar((Serializable[]) value);
        }
        Array array = ps.getConnection().createArrayOf(jdbcBaseTypeName, (Object[]) value);
        ps.setArray(index, array);
        return;
    case Types.OTHER:
        ColumnType type = column.getType();
        if (type.isId()) {
            setId(ps, index, value);
            return;
        } else if (type == ColumnType.FTSTORED) {
            ps.setString(index, (String) value);
            return;
        }
        throw new SQLException("Unhandled type: " + column.getType());
    default:
        throw new SQLException("Unhandled JDBC type: " + column.getJdbcType());
    }
}

From source file:com.micromux.cassandra.jdbc.JdbcRegressionTest.java

/**
 * Test the {@code Set} object in Cassandra.
 *///from  w w  w  .  jav a2 s . c o m
@Test
public void testObjectSet() throws Exception {
    Statement stmt = con.createStatement();

    // Create the target Column family
    String createCF = "CREATE COLUMNFAMILY t65 (key text PRIMARY KEY," + "int1 int, " + "int2 int, "
            + "intset  set<int> " + ") ;";

    stmt.execute(createCF);
    stmt.close();
    con.close();

    // open it up again to see the new CF
    con = DriverManager
            .getConnection(String.format("jdbc:cassandra://%s:%d/%s?%s", HOST, PORT, KEYSPACE, OPTIONS));

    Statement statement = con.createStatement();
    String insert = "INSERT INTO t65 (key, int1,int2,intset) VALUES ('key1',1,100,{10,20,30,40});";
    statement.executeUpdate(insert);

    ResultSet result = statement.executeQuery("SELECT intset FROM t65 where key = 'key1';");

    // read the Set of Integer back out again
    Object rsObject = result.getObject(1);
    assertNotNull("Object Should Exist", rsObject);
    assertTrue("Object Should be Set", (rsObject instanceof Set));

    int sum = 0;

    // sum up the set - it should be 100
    for (Object rsEntry : ((Set) rsObject).toArray()) {
        assertTrue("Entry should be Integer", (rsEntry instanceof Integer));
        sum += ((Integer) rsEntry).intValue();
    }

    assertEquals("Total Should be 100", 100, sum);

    //System.out.println(resultToDisplay(result,65, "with set = {10,20,30,40}"));

    String update = "UPDATE t65 SET intset=? WHERE key=?;";

    PreparedStatement pstatement = con.prepareStatement(update);
    Set<Integer> mySet = new HashSet<Integer>();
    pstatement.setObject(1, mySet, Types.OTHER);
    pstatement.setString(2, "key1");

    pstatement.executeUpdate();

    result = statement.executeQuery("SELECT * FROM t65;");

    System.out.println(resultToDisplay(result, 65, " with set = <empty>"));

}

From source file:com.netspective.axiom.sql.StoredProcedureParameter.java

/**
 * Database vendors implement the process of returning result set from a stored procedure
 * differently. This method will try to detect the database vendor through the driver name and
 * register the correct out parameter type specific to the vendor.
 * If it isn't able to guess the database from the drive name, it will return <code>Types.OTHER</code>
 * as the result set type./*  w  w  w. ja  v  a  2  s. com*/
 *
 * @param cc connection context object
 *
 * @return the JDBC type code defined by <code>java.sql.Types</code>.
 */
public int getVendorSpecificResultSetType(ConnectionContext cc) {
    // set the default type
    int sqlType = Types.OTHER;
    try {
        if (isOracleDriver(cc)) {
            // ORACLE DRIVER
            Class oClass = Class.forName("oracle.jdbc.driver.OracleTypes");
            sqlType = oClass.getField("CURSOR").getInt(null);
        }
    } catch (Exception e) {
        log.error("Failed to get the column type for the result set cursor for stored procedure" + "'"
                + parent.getProcedure() + "'.");
    }
    return sqlType;
}