/** Test of getDouble method, of inteface java.sql.CallableStatement. */
public void testGetDouble() throws Exception {
println("getDouble");
if (!isTestOutParameters()) {
return;
}
CallableStatement stmt;
double expResult = 1D;
double result = 0D;
try {
stmt = prepRegAndExec("{?= call cast(1 as double)}", 1, Types.DOUBLE);
result = stmt.getDouble(1);
} catch (Exception ex) {
fail(ex.getMessage());
}
assertEquals(expResult, result);
try {
stmt = prepRegAndExec("{?= call cast(1 as float)}", 1, Types.DOUBLE);
result = stmt.getDouble(1);
} catch (Exception ex) {
fail(ex.getMessage());
}
assertEquals(expResult, result);
}
public static void main(String a[]) {
Connection con = null;
CallableStatement callSt = null;
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
con =
DriverManager.getConnection(
"jdbc:oracle:thin:@<hostname>:<port num>:<DB name>", "user", "password");
callSt = con.prepareCall("{?= call myfunction(?,?)}");
callSt.setInt(1, 200);
// below method used to register data type of the out parameter
callSt.registerOutParameter(2, Types.DOUBLE);
callSt.execute();
Double output = callSt.getDouble(2);
System.out.println("The output returned from sql function: " + output);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
if (callSt != null) callSt.close();
if (con != null) con.close();
} catch (Exception ex) {
}
}
}
public double obtenerTotalDeCT(int idct) {
double res = 0;
Conexion conn = new Conexion();
Connection conne = null;
try {
// Pedimos una conexion al pool
conne = conn.conectar();
String query = "call obtenerTotalDeCT(?,?)";
CallableStatement cs = conne.prepareCall(query);
cs.setInt(1, idct);
cs.registerOutParameter(2, java.sql.Types.DOUBLE);
cs.execute();
res = cs.getDouble(2);
} catch (SQLException e) {
System.out.println("Ocurrió un error en la capa de datos JDBC:" + e.getMessage());
} finally {
try {
if (conne != null && !conne.isClosed()) {
conne.close();
}
} catch (SQLException e) {
System.out.println("Ocurrió un error al cerrar la conexión JDBC:" + e.getMessage());
}
}
return res;
}
@Override
public double getCallableDouble(int columnIndex) throws JdbcException {
try {
return callableStatement.getDouble(columnIndex);
} catch (SQLException ex) {
throw newJdbcException(ex);
}
}
public double getDouble(int parameterIndex) throws SQLException {
checkOpen();
try {
return _stmt.getDouble(parameterIndex);
} catch (SQLException e) {
handleException(e);
return 0;
}
}
public double getDouble(String parameterName) throws SQLException {
checkOpen();
try {
return _stmt.getDouble(parameterName);
} catch (SQLException e) {
handleException(e);
return 0;
}
}
void test() throws Exception {
sql = "?= CALL MY_SQRT(?)";
CallableStatement cs = conn.prepareCall(sql);
cs.registerOutParameter(1, Types.DOUBLE); // sqlType其实被忽略了，所以设什么都没用
cs.setDouble(2, 4.0);
cs.execute();
assertEquals(2.0, cs.getDouble(1));
cs.close();
}
public void testGetDouble01() throws Throwable {
try {
Statement stmt = con.createStatement();
stmt.execute("create temp table d_tab ( max_val float, min_val float, null_val float )");
stmt.execute("insert into d_tab values (1.0E125,1.0E-130,null)");
boolean ret =
stmt.execute(
"create or replace function "
+ "double_proc( OUT IMAX float, OUT IMIN float, OUT INUL float) as "
+ "'begin "
+ "select max_val into imax from d_tab;"
+ "select min_val into imin from d_tab;"
+ "select null_val into inul from d_tab;"
+ " end;' "
+ "language plpgsql;");
} catch (Exception ex) {
fail(ex.getMessage());
throw ex;
}
try {
CallableStatement cstmt = con.prepareCall("{ call double_proc(?,?,?) }");
cstmt.registerOutParameter(1, java.sql.Types.DOUBLE);
cstmt.registerOutParameter(2, java.sql.Types.DOUBLE);
cstmt.registerOutParameter(3, java.sql.Types.DOUBLE);
cstmt.executeUpdate();
assertTrue(cstmt.getDouble(1) == 1.0E125);
assertTrue(cstmt.getDouble(2) == 1.0E-130);
cstmt.getDouble(3);
assertTrue(cstmt.wasNull());
} catch (Exception ex) {
fail(ex.getMessage());
} finally {
try {
Statement dstmt = con.createStatement();
dstmt.execute("drop function double_proc()");
} catch (Exception ex) {
}
}
}
/** The double value */
@Override
public double getDouble(String name) throws SQLException {
try {
return _cstmt.getDouble(name);
} catch (SQLException e) {
onSqlException(e);
throw e;
} catch (RuntimeException e) {
onRuntimeException(e);
throw e;
}
}
public void test_wrapperOutputArgs() throws Exception {
Connection conn = getConnection();
PreparedStatement ps =
conn.prepareStatement(
"create procedure wrapperProc\n"
+ "(\n"
+ " out bigintCol bigint,\n"
+ " out booleanCol boolean,\n"
+ " out doubleCol double,\n"
+ " out floatCol float,\n"
+ " out intCol int,\n"
+ " out realCol real,\n"
+ " out smallintCol smallint\n"
+ ")\n"
+ "language java\n"
+ "parameter style java\n"
+ "no sql\n"
+ "external name 'org.apache.derbyTesting.functionTests.tests.lang.AnsiSignatures.wrapperProc'\n");
ps.execute();
ps.close();
CallableStatement cs = conn.prepareCall("call wrapperProc( ?, ?, ?, ?, ?, ?, ? )");
int param = 1;
cs.registerOutParameter(param++, Types.BIGINT);
cs.registerOutParameter(param++, Types.BOOLEAN);
cs.registerOutParameter(param++, Types.DOUBLE);
cs.registerOutParameter(param++, Types.FLOAT);
cs.registerOutParameter(param++, Types.INTEGER);
cs.registerOutParameter(param++, Types.REAL);
cs.registerOutParameter(param++, Types.SMALLINT);
cs.execute();
param = 1;
assertEquals(1L, cs.getLong(param++));
assertEquals(true, cs.getBoolean(param++));
assertEquals(1.0, cs.getDouble(param++), 0.0);
assertEquals(1.0, cs.getDouble(param++), 0.0);
assertEquals(1, cs.getInt(param++));
assertEquals(1.0F, cs.getFloat(param++), 0.0F);
assertEquals((short) 1, cs.getShort(param++));
}
private static void callGetMethod(
CallableStatement cs, int arg, int type, int paramType, StringBuilder strbuf)
throws Throwable {
switch (type) {
case Types.BIT:
case Types.BOOLEAN:
strbuf.append("getBoolean(" + arg + ") = ");
strbuf.append(cs.getBoolean(arg));
break;
case Types.TINYINT:
strbuf.append("getByte(" + arg + ") = ");
strbuf.append(Byte.toString(cs.getByte(arg)));
break;
case Types.SMALLINT:
strbuf.append("getShort(" + arg + ") = ");
strbuf.append(Short.toString(cs.getShort(arg)));
break;
case Types.INTEGER:
strbuf.append("getInt(" + arg + ") = ");
strbuf.append(Integer.toString(cs.getInt(arg)));
break;
case Types.BIGINT:
strbuf.append("getLong(" + arg + ") = ");
strbuf.append(Long.toString(cs.getLong(arg)));
break;
case Types.FLOAT:
case Types.REAL:
strbuf.append("getFloat(" + arg + ") = ");
strbuf.append(Float.toString(cs.getFloat(arg)));
break;
case Types.DOUBLE:
strbuf.append("getDouble(" + arg + ") = ");
strbuf.append(Double.toString(cs.getDouble(arg)));
break;
case Types.DECIMAL:
case Types.NUMERIC:
strbuf.append("getBigDecimal(" + arg + ") = ");
strbuf.append(BigDecimalHandler.getBigDecimalString(cs, arg, paramType));
break;
case Types.CHAR:
case Types.VARCHAR:
case Types.LONGVARCHAR:
strbuf.append("getString(" + arg + ") = ");
String s = cs.getString(arg);
if (s.startsWith("[B@")) s = "byte[] reference";
strbuf.append(s);
break;
case Types.BINARY:
case Types.VARBINARY:
case Types.LONGVARBINARY:
strbuf.append("getBytes(" + arg + ") = ");
byteArrayToString(cs.getBytes(arg), strbuf);
break;
case Types.DATE:
strbuf.append("getDate(" + arg + ") = ");
Date date = cs.getDate(arg);
strbuf.append(date == null ? "null" : date.toString());
break;
case Types.TIME:
strbuf.append("getTime(" + arg + ") = ");
Time time = cs.getTime(arg);
strbuf.append(time == null ? "null" : time.toString());
break;
case Types.TIMESTAMP:
strbuf.append("getTimestamp(" + arg + ") = ");
Timestamp timestamp = cs.getTimestamp(arg);
strbuf.append(timestamp == null ? "null" : timestamp.toString());
break;
case Types.OTHER:
strbuf.append("getObject(" + arg + ") = ");
Object o = cs.getObject(arg);
if (o == null) {
strbuf.append("null");
} else if (o instanceof byte[]) {
byteArrayToString((byte[]) o, strbuf);
} else {
strbuf.append(o.toString());
}
break;
default:
throw new Throwable("TEST ERROR: unexpected type " + type);
}
}
@SuppressWarnings("unchecked")
public static <T> T getFromStatement(ExecuteContext ctx, Class<? extends T> type, int index)
throws SQLException {
CallableStatement stmt = (CallableStatement) ctx.statement();
if (type == Blob.class) {
return (T) stmt.getBlob(index);
} else if (type == Boolean.class) {
return (T) checkWasNull(stmt, Boolean.valueOf(stmt.getBoolean(index)));
} else if (type == BigInteger.class) {
BigDecimal result = stmt.getBigDecimal(index);
return (T) (result == null ? null : result.toBigInteger());
} else if (type == BigDecimal.class) {
return (T) stmt.getBigDecimal(index);
} else if (type == Byte.class) {
return (T) checkWasNull(stmt, Byte.valueOf(stmt.getByte(index)));
} else if (type == byte[].class) {
return (T) stmt.getBytes(index);
} else if (type == Clob.class) {
return (T) stmt.getClob(index);
} else if (type == Date.class) {
return (T) stmt.getDate(index);
} else if (type == Double.class) {
return (T) checkWasNull(stmt, Double.valueOf(stmt.getDouble(index)));
} else if (type == Float.class) {
return (T) checkWasNull(stmt, Float.valueOf(stmt.getFloat(index)));
} else if (type == Integer.class) {
return (T) checkWasNull(stmt, Integer.valueOf(stmt.getInt(index)));
} else if (type == Long.class) {
return (T) checkWasNull(stmt, Long.valueOf(stmt.getLong(index)));
} else if (type == Short.class) {
return (T) checkWasNull(stmt, Short.valueOf(stmt.getShort(index)));
} else if (type == String.class) {
return (T) stmt.getString(index);
} else if (type == Time.class) {
return (T) stmt.getTime(index);
} else if (type == Timestamp.class) {
return (T) stmt.getTimestamp(index);
} else if (type == YearToMonth.class) {
if (ctx.getDialect() == POSTGRES) {
Object object = stmt.getObject(index);
return (T) (object == null ? null : PostgresUtils.toYearToMonth(object));
} else {
String string = stmt.getString(index);
return (T) (string == null ? null : YearToMonth.valueOf(string));
}
} else if (type == DayToSecond.class) {
if (ctx.getDialect() == POSTGRES) {
Object object = stmt.getObject(index);
return (T) (object == null ? null : PostgresUtils.toDayToSecond(object));
} else {
String string = stmt.getString(index);
return (T) (string == null ? null : DayToSecond.valueOf(string));
}
} else if (type == UByte.class) {
String string = stmt.getString(index);
return (T) (string == null ? null : UByte.valueOf(string));
} else if (type == UShort.class) {
String string = stmt.getString(index);
return (T) (string == null ? null : UShort.valueOf(string));
} else if (type == UInteger.class) {
String string = stmt.getString(index);
return (T) (string == null ? null : UInteger.valueOf(string));
} else if (type == ULong.class) {
String string = stmt.getString(index);
return (T) (string == null ? null : ULong.valueOf(string));
}
// The type byte[] is handled earlier. byte[][] can be handled here
else if (type.isArray()) {
return (T) convertArray(stmt.getObject(index), (Class<? extends Object[]>) type);
} else if (ArrayRecord.class.isAssignableFrom(type)) {
return (T) getArrayRecord(ctx, stmt.getArray(index), (Class<? extends ArrayRecord<?>>) type);
} else if (EnumType.class.isAssignableFrom(type)) {
return getEnumType(type, stmt.getString(index));
} else if (MasterDataType.class.isAssignableFrom(type)) {
return (T) getMasterDataType(type, stmt.getString(index));
} else if (UDTRecord.class.isAssignableFrom(type)) {
switch (ctx.getDialect()) {
case POSTGRES:
return (T) pgNewUDTRecord(type, stmt.getObject(index));
}
return (T) stmt.getObject(index, DataTypes.udtRecords());
} else if (Result.class.isAssignableFrom(type)) {
ResultSet nested = (ResultSet) stmt.getObject(index);
return (T) getNewFactory(ctx).fetch(nested);
} else {
return (T) stmt.getObject(index);
}
}
public void retrieveOutVariables(int ColIndex, cfSession _Session, CallableStatement _stmt)
throws SQLException, cfmRunTimeException {
boolean b;
byte[] bin;
int i;
long l;
double dbl;
float flt;
java.sql.Date dt;
java.sql.Time t;
Timestamp ts;
ResultSet rs;
String str;
cfData outData = null;
if (!isOUT()) return;
switch (cfSqlType) {
case CF_SQL_BIT:
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
b = _stmt.getBoolean(paramName);
} else {
b = _stmt.getBoolean(ColIndex);
}
if (!_stmt.wasNull()) outData = cfBooleanData.getcfBooleanData(b);
break;
case CF_SQL_BINARY:
case CF_SQL_VARBINARY:
case CF_SQL_BLOB:
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
bin = _stmt.getBytes(paramName);
} else {
bin = _stmt.getBytes(ColIndex);
}
if ((!_stmt.wasNull()) && (bin != null)) {
outData = new cfBinaryData(bin);
}
break;
case CF_SQL_SMALLINT:
case CF_SQL_INTEGER:
case CF_SQL_TINYINT:
try {
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
i = _stmt.getInt(paramName);
} else {
i = _stmt.getInt(ColIndex);
}
if (!_stmt.wasNull()) outData = new cfNumberData(i);
} catch (NumberFormatException e) {
// With JDK 1.3 and the JDBC-ODBC bridge, the getInt() method will
// throw a number format exception for in/out params so just ignore it.
// Ignoring it allows us to retrieve the out param values.
}
break;
case CF_SQL_BIGINT:
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
l = _stmt.getLong(paramName);
} else {
l = _stmt.getLong(ColIndex);
}
if (!_stmt.wasNull()) outData = new cfNumberData(l);
break;
case CF_SQL_DECIMAL:
case CF_SQL_NUMERIC:
dbl = getBigDecimalAsDouble(_stmt, useNamedParameters, paramName, ColIndex);
if (!_stmt.wasNull()) outData = new cfNumberData(dbl);
break;
case CF_SQL_DOUBLE:
case CF_SQL_FLOAT:
case CF_SQL_MONEY:
case CF_SQL_MONEY4:
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
dbl = _stmt.getDouble(paramName);
} else {
dbl = _stmt.getDouble(ColIndex);
}
if (!_stmt.wasNull()) outData = new cfNumberData(dbl);
break;
case CF_SQL_REAL:
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
flt = _stmt.getFloat(paramName);
} else {
flt = _stmt.getFloat(ColIndex);
}
// For some reason casting a float to a double doesn't return a double
// that exactly matches the original float so we'll use the less efficient
// algorithm of converting the float to a string and the string to a double.
// If for some reason this fails then we'll revert to casting the float to
// a double.
if (!_stmt.wasNull()) {
try {
dbl = Double.valueOf(Float.toString(flt)).doubleValue();
} catch (Exception e) {
dbl = (double) flt;
}
outData = new cfNumberData(dbl);
}
break;
case CF_SQL_DATE:
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
dt = _stmt.getDate(paramName);
} else {
dt = _stmt.getDate(ColIndex);
}
if ((!_stmt.wasNull()) && (dt != null)) {
outData = new cfDateData(dt);
}
break;
case CF_SQL_TIME:
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
t = _stmt.getTime(paramName);
} else {
t = _stmt.getTime(ColIndex);
}
if ((!_stmt.wasNull()) && (t != null)) {
outData = new cfDateData(t);
}
break;
case CF_SQL_TIMESTAMP:
try {
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
ts = _stmt.getTimestamp(paramName);
} else {
ts = _stmt.getTimestamp(ColIndex);
}
if ((!_stmt.wasNull()) && (ts != null)) {
outData = new cfDateData(ts);
}
} catch (NullPointerException e) {
// With JDK 1.3 and the JDBC-ODBC bridge, the getTimestamp() method will
// throw a null ptr exception when the underlying value is null so just ignore it.
}
break;
case CF_SQL_REFCURSOR:
// This CF SQL Type is only used with Oracle for result sets returned by a
// stored procedure.
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
rs = (ResultSet) _stmt.getObject(paramName);
} else {
rs = (ResultSet) _stmt.getObject(ColIndex);
}
if ((!_stmt.wasNull()) && (rs != null)) {
outData = new cfQueryResultData(rs, "Stored Procedure", maxLength);
}
break;
default:
// With the Oracle JDBC driver, if we set the parameters using named parameters then
// we must retrieve them using named parameters too.
if (useNamedParameters) {
str = _stmt.getString(paramName);
} else {
str = _stmt.getString(ColIndex);
}
if ((!_stmt.wasNull()) && (str != null)) {
outData = new cfStringData(str);
}
break;
}
_Session.setData(outVariable, (outData == null ? cfNullData.NULL : outData));
}
public double getDouble(int parameterIndex) throws SQLException {
return passThru.getDouble(parameterIndex);
}
public double getDouble(String parameterName) throws SQLException {
return passThru.getDouble(parameterName);
}
/** @see java.sql.CallableStatement#getDouble(int) */
public double getDouble(int parameterIndex) throws SQLException {
return original.getDouble(parameterIndex);
}
/** @see java.sql.CallableStatement#getDouble(java.lang.String) */
public double getDouble(String parameterName) throws SQLException {
return original.getDouble(parameterName);
}