diff --git a/pgjdbc/src/main/java/org/postgresql/jdbc/PgResultSet.java b/pgjdbc/src/main/java/org/postgresql/jdbc/PgResultSet.java index c3e2cbf..7090db8 100644 --- a/pgjdbc/src/main/java/org/postgresql/jdbc/PgResultSet.java +++ b/pgjdbc/src/main/java/org/postgresql/jdbc/PgResultSet.java @@ -256,118 +256,122 @@ public class PgResultSet implements ResultSet, org.postgresql.PGRefCursorResultS return getURL(findColumn(columnName)); } - protected Object internalGetObject(int columnIndex, Field field) throws SQLException { - switch (getSQLType(columnIndex)) { - case Types.BOOLEAN: - return getBoolean(columnIndex); - case Types.BIT: - return getBit(columnIndex); - case Types.SQLXML: - return getSQLXML(columnIndex); - case Types.TINYINT: - case Types.SMALLINT: - case Types.INTEGER: - return getInt(columnIndex); - case Types.BIGINT: - return getLong(columnIndex); - case TypeInfoCache.bIntegerType: - return getBigInteger(columnIndex); - case Types.NUMERIC: - case Types.DECIMAL: - int scale; - if (field.getMod() == -1) { - return getBigDecimal(columnIndex, -1); - } else { - scale = (short)((field.getMod() - 4) & 0xffff); - return getBigDecimal(columnIndex, (Math.max(scale, -1))); + protected Object internalGetObject(int columnIndex, Field field) throws SQLException { + switch (getSQLType(columnIndex)) { + case Types.BOOLEAN: + return getBoolean(columnIndex); + case Types.BIT: + return getBit(columnIndex); + case Types.SQLXML: + return getSQLXML(columnIndex); + case Types.TINYINT: + case Types.SMALLINT: + case Types.INTEGER: + if (field.getPGType().equals("uint4")) { + return getLong(columnIndex); + } + return getInt(columnIndex); + case Types.BIGINT: + if (field.getPGType().equals("uint8")) { + return getBigInteger(columnIndex); + } + return getLong(columnIndex); + case Types.NUMERIC: + case Types.DECIMAL: + int scale; + if (field.getMod() == -1) { + return getBigDecimal(columnIndex, -1); + } else { + scale = (short) ((field.getMod() - 4) & 0xffff); + return getBigDecimal(columnIndex, (Math.max(scale, -1))); + } + case Types.REAL: + return getFloat(columnIndex); + case Types.FLOAT: + case Types.DOUBLE: + return getDouble(columnIndex); + case Types.CHAR: + case Types.VARCHAR: + case Types.LONGVARCHAR: + return getString(columnIndex); + case Types.DATE: + return getDate(columnIndex); + case Types.TIME: + return getTime(columnIndex); + case Types.TIMESTAMP: + return getTimestamp(columnIndex, null); + case Types.BINARY: + case Types.VARBINARY: + case Types.LONGVARBINARY: + return getBytes(columnIndex); + case Types.ARRAY: + return getArray(columnIndex); + case Types.CLOB: + return getClob(columnIndex); + case Types.BLOB: + return getBlob(columnIndex); + case Types.STRUCT: + return getStruct(columnIndex); + + default: + String type = getPGType(columnIndex); + + // if the backend doesn't know the type then coerce to String + if (type.equals("unknown")) { + return getString(columnIndex); + } + + if (type.equals("uuid")) { + if (isBinary(columnIndex)) { + return getUUID(this_row[columnIndex - 1]); + } + return getUUID(getString(columnIndex)); + } + + // Specialized support for ref cursors is neater. + if (type.equals("refcursor")) { + // Fetch all results. + String cursorName = getString(columnIndex); + + StringBuilder sb = new StringBuilder("FETCH ALL IN "); + Utils.escapeIdentifier(sb, cursorName); + + // nb: no BEGIN triggered here. This is fine. If someone + // committed, and the cursor was not holdable (closing the + // cursor), we avoid starting a new xact and promptly causing + // it to fail. If the cursor *was* holdable, we don't want a + // new xact anyway since holdable cursor state isn't affected + // by xact boundaries. If our caller didn't commit at all, or + // autocommit was on, then we wouldn't issue a BEGIN anyway. + // + // We take the scrollability from the statement, but until + // we have updatable cursors it must be readonly. + ResultSet rs = + connection.execSQLQuery(sb.toString(), resultsettype, ResultSet.CONCUR_READ_ONLY); + // + // In long running transactions these backend cursors take up memory space + // we could close in rs.close(), but if the transaction is closed before the result set, + // then + // the cursor no longer exists + + sb.setLength(0); + sb.append("CLOSE "); + Utils.escapeIdentifier(sb, cursorName); + connection.execSQLUpdate(sb.toString()); + ((PgResultSet) rs).setRefCursor(cursorName); + return rs; + } + if ("hstore".equals(type)) { + if (isBinary(columnIndex)) { + return HStoreConverter.fromBytes(this_row[columnIndex - 1], connection.getEncoding()); + } + return HStoreConverter.fromString(getString(columnIndex)); + } + + // Caller determines what to do (JDBC3 overrides in this case) + return null; } - case Types.REAL: - return getFloat(columnIndex); - case Types.FLOAT: - case Types.DOUBLE: - return getDouble(columnIndex); - case Types.CHAR: - case Types.VARCHAR: - case Types.LONGVARCHAR: - return getString(columnIndex); - case Types.DATE: - return getDate(columnIndex); - case Types.TIME: - return getTime(columnIndex); - case Types.TIMESTAMP: - return getTimestamp(columnIndex, null); - case Types.BINARY: - case Types.VARBINARY: - case Types.LONGVARBINARY: - return getBytes(columnIndex); - case Types.ARRAY: - return getArray(columnIndex); - case Types.CLOB: - return getClob(columnIndex); - case Types.BLOB: - return getBlob(columnIndex); - case Types.STRUCT: - return getStruct(columnIndex); - - default: - String type = getPGType(columnIndex); - - // if the backend doesn't know the type then coerce to String - if (type.equals("unknown")) { - return getString(columnIndex); - } - - if (type.equals("uuid")) { - if (isBinary(columnIndex)) { - return getUUID(this_row[columnIndex - 1]); - } - return getUUID(getString(columnIndex)); - } - - // Specialized support for ref cursors is neater. - if (type.equals("refcursor")) { - // Fetch all results. - String cursorName = getString(columnIndex); - - StringBuilder sb = new StringBuilder("FETCH ALL IN "); - Utils.escapeIdentifier(sb, cursorName); - - // nb: no BEGIN triggered here. This is fine. If someone - // committed, and the cursor was not holdable (closing the - // cursor), we avoid starting a new xact and promptly causing - // it to fail. If the cursor *was* holdable, we don't want a - // new xact anyway since holdable cursor state isn't affected - // by xact boundaries. If our caller didn't commit at all, or - // autocommit was on, then we wouldn't issue a BEGIN anyway. - // - // We take the scrollability from the statement, but until - // we have updatable cursors it must be readonly. - ResultSet rs = - connection.execSQLQuery(sb.toString(), resultsettype, ResultSet.CONCUR_READ_ONLY); - // - // In long running transactions these backend cursors take up memory space - // we could close in rs.close(), but if the transaction is closed before the result set, - // then - // the cursor no longer exists - - sb.setLength(0); - sb.append("CLOSE "); - Utils.escapeIdentifier(sb, cursorName); - connection.execSQLUpdate(sb.toString()); - ((PgResultSet) rs).setRefCursor(cursorName); - return rs; - } - if ("hstore".equals(type)) { - if (isBinary(columnIndex)) { - return HStoreConverter.fromBytes(this_row[columnIndex - 1], connection.getEncoding()); - } - return HStoreConverter.fromString(getString(columnIndex)); - } - - // Caller determines what to do (JDBC3 overrides in this case) - return null; } - } /** * Get the PGStruct object based on parameter index diff --git a/pgjdbc/src/main/java/org/postgresql/jdbc/TypeInfoCache.java b/pgjdbc/src/main/java/org/postgresql/jdbc/TypeInfoCache.java index 4ecf6c0..629cd60 100644 --- a/pgjdbc/src/main/java/org/postgresql/jdbc/TypeInfoCache.java +++ b/pgjdbc/src/main/java/org/postgresql/jdbc/TypeInfoCache.java @@ -68,8 +68,6 @@ public class TypeInfoCache implements TypeInfo { private static ConcurrentHashMap pgTypes = new ConcurrentHashMap<>(); - public static final int bIntegerType = 1324; - // SELECT LENGTH(pow(10::numeric,131071)); 131071 = 2^17-1 public static final int NUMERIC_MAX_DISPLAYSIZE = 131089; @@ -77,48 +75,48 @@ public class TypeInfoCache implements TypeInfo { // openGauss accepts float(p) as numeric Type and the scale is -32768(PG_INT16_MIN) public static final int FLOATSCALE = -32768; - // basic pg types info: - // 0 - type name - // 1 - type oid - // 2 - sql type - // 3 - java class - // 4 - array type oid - private static final Object[][] types = { - {"int1", Oid.INT1, Types.TINYINT, "java.lang.Integer", Oid.INT1_ARRAY}, - {"int2", Oid.INT2, Types.SMALLINT, "java.lang.Integer", Oid.INT2_ARRAY}, - {"int4", Oid.INT4, Types.INTEGER, "java.lang.Integer", Oid.INT4_ARRAY}, - {"oid", Oid.OID, Types.BIGINT, "java.lang.Long", Oid.OID_ARRAY}, - {"int8", Oid.INT8, Types.BIGINT, "java.lang.Long", Oid.INT8_ARRAY}, - {"uint1", Oid.UINT1, Types.SMALLINT, "java.lang.Integer", Oid.UINT1_ARRAY}, - {"uint2", Oid.UINT2, Types.INTEGER, "java.lang.Integer", Oid.UINT2_ARRAY}, - {"uint4", Oid.UINT4, Types.BIGINT, "java.lang.Long", Oid.UINT4_ARRAY}, - {"uint8", Oid.UINT8, bIntegerType, "java.math.BigInteger", Oid.UINT8_ARRAY}, - {"money", Oid.MONEY, Types.DOUBLE, "java.lang.Double", Oid.MONEY_ARRAY}, - {"numeric", Oid.NUMERIC, Types.NUMERIC, "java.math.BigDecimal", Oid.NUMERIC_ARRAY}, - {"float4", Oid.FLOAT4, Types.REAL, "java.lang.Float", Oid.FLOAT4_ARRAY}, - {"float8", Oid.FLOAT8, Types.DOUBLE, "java.lang.Double", Oid.FLOAT8_ARRAY}, - {"char", Oid.CHAR, Types.CHAR, "java.lang.String", Oid.CHAR_ARRAY}, - {"bpchar", Oid.BPCHAR, Types.CHAR, "java.lang.String", Oid.BPCHAR_ARRAY}, - {"varchar", Oid.VARCHAR, Types.VARCHAR, "java.lang.String", Oid.VARCHAR_ARRAY}, - {"text", Oid.TEXT, Types.VARCHAR, "java.lang.String", Oid.TEXT_ARRAY}, - {"name", Oid.NAME, Types.VARCHAR, "java.lang.String", Oid.NAME_ARRAY}, - {"bytea", Oid.BYTEA, Types.BINARY, "[B", Oid.BYTEA_ARRAY}, - {"bool", Oid.BOOL, Types.BOOLEAN, "java.lang.Boolean", Oid.BOOL_ARRAY}, - {"bit", Oid.BIT, Types.BIT, "java.lang.Boolean", Oid.BIT_ARRAY}, - {"date", Oid.DATE, Types.DATE, "java.sql.Date", Oid.DATE_ARRAY}, - {"time", Oid.TIME, Types.TIME, "java.sql.Time", Oid.TIME_ARRAY}, - {"timetz", Oid.TIMETZ, Types.TIME, "java.sql.Time", Oid.TIMETZ_ARRAY}, - {"timestamp", Oid.TIMESTAMP, Types.TIMESTAMP, "java.sql.Timestamp", Oid.TIMESTAMP_ARRAY}, - {"smalldatetime", Oid.SMALLDATETIME, Types.TIMESTAMP, "java.lang.Timestamp", Oid.SMALLDATETIME_ARRAY}, - {"timestamptz", Oid.TIMESTAMPTZ, Types.TIMESTAMP, "java.sql.Timestamp", - Oid.TIMESTAMPTZ_ARRAY}, - {"json", Oid.JSON, Types.OTHER, "org.postgresql.util.PGobject", Oid.JSON_ARRAY}, - {"point", Oid.POINT, Types.OTHER, "org.postgresql.geometric.PGpoint", Oid.POINT_ARRAY}, - {"blob", Oid.BLOB, Types.BLOB, "org.postgresql.util.PGobject", -1}, - {"clob", Oid.CLOB, Types.CLOB, "org.postgresql.util.PGobject", -1}, - {"nvarchar2", Oid.NVARCHAR2, Types.VARCHAR, "java.lang.String", Oid.NVARCHAR2_ARRAY}, - {"refcursor", Oid.REF_CURSOR, Types.REF_CURSOR, "java.sql.ResultSet", Oid.REF_CURSOR_ARRAY} - }; + // basic pg types info: + // 0 - type name + // 1 - type oid + // 2 - sql type + // 3 - java class + // 4 - array type oid + private static final Object[][] types = { + {"int1", Oid.INT1, Types.TINYINT, "java.lang.Integer", Oid.INT1_ARRAY}, + {"int2", Oid.INT2, Types.SMALLINT, "java.lang.Integer", Oid.INT2_ARRAY}, + {"int4", Oid.INT4, Types.INTEGER, "java.lang.Integer", Oid.INT4_ARRAY}, + {"oid", Oid.OID, Types.BIGINT, "java.lang.Long", Oid.OID_ARRAY}, + {"int8", Oid.INT8, Types.BIGINT, "java.lang.Long", Oid.INT8_ARRAY}, + {"uint1", Oid.UINT1, Types.TINYINT, "java.lang.Integer", Oid.UINT1_ARRAY}, + {"uint2", Oid.UINT2, Types.SMALLINT, "java.lang.Integer", Oid.UINT2_ARRAY}, + {"uint4", Oid.UINT4, Types.INTEGER, "java.lang.Integer", Oid.UINT4_ARRAY}, + {"uint8", Oid.UINT8, Types.BIGINT, "java.lang.Long", Oid.UINT8_ARRAY}, + {"money", Oid.MONEY, Types.DOUBLE, "java.lang.Double", Oid.MONEY_ARRAY}, + {"numeric", Oid.NUMERIC, Types.NUMERIC, "java.math.BigDecimal", Oid.NUMERIC_ARRAY}, + {"float4", Oid.FLOAT4, Types.REAL, "java.lang.Float", Oid.FLOAT4_ARRAY}, + {"float8", Oid.FLOAT8, Types.DOUBLE, "java.lang.Double", Oid.FLOAT8_ARRAY}, + {"char", Oid.CHAR, Types.CHAR, "java.lang.String", Oid.CHAR_ARRAY}, + {"bpchar", Oid.BPCHAR, Types.CHAR, "java.lang.String", Oid.BPCHAR_ARRAY}, + {"varchar", Oid.VARCHAR, Types.VARCHAR, "java.lang.String", Oid.VARCHAR_ARRAY}, + {"text", Oid.TEXT, Types.VARCHAR, "java.lang.String", Oid.TEXT_ARRAY}, + {"name", Oid.NAME, Types.VARCHAR, "java.lang.String", Oid.NAME_ARRAY}, + {"bytea", Oid.BYTEA, Types.BINARY, "[B", Oid.BYTEA_ARRAY}, + {"bool", Oid.BOOL, Types.BOOLEAN, "java.lang.Boolean", Oid.BOOL_ARRAY}, + {"bit", Oid.BIT, Types.BIT, "java.lang.Boolean", Oid.BIT_ARRAY}, + {"date", Oid.DATE, Types.DATE, "java.sql.Date", Oid.DATE_ARRAY}, + {"time", Oid.TIME, Types.TIME, "java.sql.Time", Oid.TIME_ARRAY}, + {"timetz", Oid.TIMETZ, Types.TIME, "java.sql.Time", Oid.TIMETZ_ARRAY}, + {"timestamp", Oid.TIMESTAMP, Types.TIMESTAMP, "java.sql.Timestamp", Oid.TIMESTAMP_ARRAY}, + {"smalldatetime", Oid.SMALLDATETIME, Types.TIMESTAMP, "java.lang.Timestamp", Oid.SMALLDATETIME_ARRAY}, + {"timestamptz", Oid.TIMESTAMPTZ, Types.TIMESTAMP, "java.sql.Timestamp", + Oid.TIMESTAMPTZ_ARRAY}, + {"json", Oid.JSON, Types.OTHER, "org.postgresql.util.PGobject", Oid.JSON_ARRAY}, + {"point", Oid.POINT, Types.OTHER, "org.postgresql.geometric.PGpoint", Oid.POINT_ARRAY}, + {"blob", Oid.BLOB, Types.BLOB, "org.postgresql.util.PGobject", -1}, + {"clob", Oid.CLOB, Types.CLOB, "org.postgresql.util.PGobject", -1}, + {"nvarchar2", Oid.NVARCHAR2, Types.VARCHAR, "java.lang.String", Oid.NVARCHAR2_ARRAY}, + {"refcursor", Oid.REF_CURSOR, Types.REF_CURSOR, "java.sql.ResultSet", Oid.REF_CURSOR_ARRAY} + }; /** * PG maps several alias to real type names. When we do queries against pg_catalog, we must use diff --git a/pgjdbc/src/test/java/org/postgresql/test/dolphintest/IntTest.java b/pgjdbc/src/test/java/org/postgresql/test/dolphintest/IntTest.java index 83a6c2d..a10ebd3 100644 --- a/pgjdbc/src/test/java/org/postgresql/test/dolphintest/IntTest.java +++ b/pgjdbc/src/test/java/org/postgresql/test/dolphintest/IntTest.java @@ -5,12 +5,14 @@ import org.postgresql.test.TestUtil; import org.postgresql.test.jdbc2.BaseTest4B; import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.Statement; import java.sql.Types; +import java.sql.Statement; +import java.sql.ResultSet; +import java.sql.ResultSetMetaData; -import static org.junit.Assert.*; +import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; public class IntTest extends BaseTest4B { /* @@ -116,4 +118,28 @@ public class IntTest extends BaseTest4B { TestUtil.dropTable(con, "test_tinyint2"); } + + /* + * Tests int type + */ + @Test + public void testIntType() throws Exception { + TestUtil.createTable(con, "test_int", "c1 int1,c2 int2,c3 int4," + + "c4 int8,uc1 uint1,uc2 uint2,uc3 uint4,uc4 uint8"); + try (Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery("SELECT * FROM test_int")) { + ResultSetMetaData rsmd = rs.getMetaData(); + assertEquals(8, rsmd.getColumnCount()); + assertEquals(Types.TINYINT, rsmd.getColumnType(1)); + assertEquals(Types.SMALLINT, rsmd.getColumnType(2)); + assertEquals(Types.INTEGER, rsmd.getColumnType(3)); + assertEquals(Types.BIGINT, rsmd.getColumnType(4)); + assertEquals(Types.TINYINT, rsmd.getColumnType(5)); + assertEquals(Types.SMALLINT, rsmd.getColumnType(6)); + assertEquals(Types.INTEGER, rsmd.getColumnType(7)); + assertEquals(Types.BIGINT, rsmd.getColumnType(8)); + } finally { + TestUtil.dropTable(con, "test_int"); + } + } } diff --git a/pgjdbc/src/test/java/org/postgresql/test/dolphintest/UnsignedTest.java b/pgjdbc/src/test/java/org/postgresql/test/dolphintest/UnsignedTest.java index 5e3c469..946d1ca 100644 --- a/pgjdbc/src/test/java/org/postgresql/test/dolphintest/UnsignedTest.java +++ b/pgjdbc/src/test/java/org/postgresql/test/dolphintest/UnsignedTest.java @@ -2,15 +2,21 @@ package org.postgresql.test.dolphintest; import org.junit.Assert; import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; + import org.postgresql.test.TestUtil; import org.postgresql.test.jdbc2.BaseTest4B; import java.math.BigInteger; -import java.sql.*; +import java.sql.PreparedStatement; +import java.sql.Types; +import java.sql.Statement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Array; -import static org.junit.Assert.*; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; public class UnsignedTest extends BaseTest4B { /** @@ -21,19 +27,20 @@ public class UnsignedTest extends BaseTest4B { public void testUint1() throws SQLException { TestUtil.createTable(con, "test_unit1", "id uint1"); - PreparedStatement pstmt = con.prepareStatement("INSERT INTO test_unit1 VALUES (?)"); - pstmt.setObject(1, 234, Types.SMALLINT); - pstmt.executeUpdate(); + try (PreparedStatement pstmt = con.prepareStatement("INSERT INTO test_unit1 VALUES (?)")) { + pstmt.setObject(1, 234, Types.SMALLINT); + pstmt.executeUpdate(); + } - Statement stmt = con.createStatement(); - ResultSet rs = stmt.executeQuery("SELECT id FROM test_unit1"); - - assertTrue(rs.next()); - Object r1 = rs.getObject(1); - assertNotNull(r1); - assertEquals(234, r1); - - TestUtil.dropTable(con, "test_unit1"); + try (Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery("SELECT id FROM test_unit1");) { + assertTrue(rs.next()); + Object r1 = rs.getObject(1); + assertNotNull(r1); + assertEquals(234, r1); + } finally { + TestUtil.dropTable(con, "test_unit1"); + } } /** @@ -44,19 +51,20 @@ public class UnsignedTest extends BaseTest4B { public void testUint2() throws SQLException { TestUtil.createTable(con, "test_unit2", "id uint2"); - PreparedStatement pstmt = con.prepareStatement("INSERT INTO test_unit2 VALUES (?)"); - pstmt.setObject(1, 65518, Types.INTEGER); - pstmt.executeUpdate(); + try (PreparedStatement pstmt = con.prepareStatement("INSERT INTO test_unit2 VALUES (?)")) { + pstmt.setObject(1, 65518, Types.INTEGER); + pstmt.executeUpdate(); + } - Statement stmt = con.createStatement(); - ResultSet rs = stmt.executeQuery("SELECT id FROM test_unit2"); - - assertTrue(rs.next()); - Object r1 = rs.getObject(1); - assertNotNull(r1); - assertEquals(65518, r1); - - TestUtil.dropTable(con, "test_unit2"); + try (Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery("SELECT id FROM test_unit2")) { + assertTrue(rs.next()); + Object r1 = rs.getObject(1); + assertNotNull(r1); + assertEquals(65518, r1); + } finally { + TestUtil.dropTable(con, "test_unit2"); + } } /** @@ -67,20 +75,20 @@ public class UnsignedTest extends BaseTest4B { public void testUint4() throws SQLException { TestUtil.createTable(con, "test_unit4", "id uint4"); - PreparedStatement pstmt = con.prepareStatement("INSERT INTO test_unit4 VALUES (?)"); - long l = 4294967282L; - pstmt.setObject(1, l, Types.BIGINT); - pstmt.executeUpdate(); + try (PreparedStatement pstmt = con.prepareStatement("INSERT INTO test_unit4 VALUES (?)")) { + pstmt.setObject(1, 4294967282L, Types.BIGINT); + pstmt.executeUpdate(); + } - Statement stmt = con.createStatement(); - ResultSet rs = stmt.executeQuery("SELECT id FROM test_unit4"); - - assertTrue(rs.next()); - Object r1 = rs.getObject(1); - assertNotNull(r1); - assertEquals(l, r1); - - TestUtil.dropTable(con, "test_unit4"); + try (Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery("SELECT id FROM test_unit4")) { + assertTrue(rs.next()); + Object r1 = rs.getObject(1); + assertNotNull(r1); + assertEquals(4294967282L, r1); + } finally { + TestUtil.dropTable(con, "test_unit4"); + } } /** @@ -90,109 +98,113 @@ public class UnsignedTest extends BaseTest4B { @Test public void testUint8() throws SQLException { TestUtil.createTable(con, "test_unit8", "id uint8"); - - PreparedStatement pstmt = con.prepareStatement("INSERT INTO test_unit8 VALUES (?)"); BigInteger b = new BigInteger("9223372036859999999"); - pstmt.setObject(1, b, Types.NUMERIC); - pstmt.executeUpdate(); - BigInteger b2 = new BigInteger("15223372036859999999"); - pstmt.setObject(1, b2, Types.NUMERIC); - pstmt.executeUpdate(); + try (PreparedStatement pstmt = con.prepareStatement("INSERT INTO test_unit8 VALUES (?)")) { + pstmt.setObject(1, b, Types.NUMERIC); + pstmt.executeUpdate(); - Statement stmt = con.createStatement(); - ResultSet rs = stmt.executeQuery("SELECT id FROM test_unit8"); + pstmt.setObject(1, b2, Types.NUMERIC); + pstmt.executeUpdate(); + } - assertTrue(rs.next()); - Object r1 = rs.getObject(1); - assertNotNull(r1); - assertEquals(b, r1); + try (Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery("SELECT id FROM test_unit8")) { + assertTrue(rs.next()); + Object r1 = rs.getObject(1); + assertNotNull(r1); + assertEquals(b, r1); - assertTrue(rs.next()); - Object r2 = rs.getObject(1); - assertNotNull(r2); - assertEquals(b2, r2); - - TestUtil.dropTable(con, "test_unit8"); + assertTrue(rs.next()); + Object r2 = rs.getObject(1); + assertNotNull(r2); + assertEquals(b2, r2); + } finally { + TestUtil.dropTable(con, "test_unit8"); + } } @Test public void testCreateArrayOfUint1() throws SQLException { - PreparedStatement pstmt = con.prepareStatement("SELECT ?::uint1[]"); - Short[] in = new Short[3]; - in[0] = 0; - in[1] = 188; - in[2] = 234; - pstmt.setArray(1, con.createArrayOf("uint1", in)); + try (PreparedStatement pstmt = con.prepareStatement("SELECT ?::uint1[]")) { + Object[] in = new Object[3]; + in[0] = 0; + in[1] = 88; + in[2] = 115; + pstmt.setArray(1, con.createArrayOf("uint1", in)); + try (ResultSet rs = pstmt.executeQuery()) { + Assert.assertTrue(rs.next()); + Array arr = rs.getArray(1); + Object[] out = (Object[]) arr.getArray(); - ResultSet rs = pstmt.executeQuery(); - Assert.assertTrue(rs.next()); - Array arr = rs.getArray(1); - Short[] out = (Short[]) arr.getArray(); - - Assert.assertEquals(3, out.length); - Assert.assertEquals(0, out[0].shortValue()); - Assert.assertEquals(188, out[1].shortValue()); - Assert.assertEquals(234, out[2].shortValue()); + Assert.assertEquals(3, out.length); + Assert.assertEquals(0, Integer.parseInt(out[0].toString())); + Assert.assertEquals(88, Integer.parseInt(out[1].toString())); + Assert.assertEquals(115, Integer.parseInt(out[2].toString())); + } + } } @Test public void testCreateArrayOfUint2() throws SQLException { - PreparedStatement pstmt = con.prepareStatement("SELECT ?::uint2[]"); - Integer[] in = new Integer[3]; - in[0] = 0; - in[1] = 12654; - in[2] = 65535; - pstmt.setArray(1, con.createArrayOf("uint2", in)); + try (PreparedStatement pstmt = con.prepareStatement("SELECT ?::uint2[]")) { + Short[] in = new Short[3]; + in[0] = 0; + in[1] = 12654; + in[2] = 30035; + pstmt.setArray(1, con.createArrayOf("uint2", in)); + try (ResultSet rs = pstmt.executeQuery()) { + Assert.assertTrue(rs.next()); + Array arr = rs.getArray(1); + Short[] out = (Short[]) arr.getArray(); - ResultSet rs = pstmt.executeQuery(); - Assert.assertTrue(rs.next()); - Array arr = rs.getArray(1); - Integer[] out = (Integer[]) arr.getArray(); - - Assert.assertEquals(3, out.length); - Assert.assertEquals(0, out[0].intValue()); - Assert.assertEquals(12654, out[1].intValue()); - Assert.assertEquals(65535, out[2].intValue()); + Assert.assertEquals(3, out.length); + Assert.assertEquals(0, out[0].shortValue()); + Assert.assertEquals(12654, out[1].shortValue()); + Assert.assertEquals(30035, out[2].shortValue()); + } + } } @Test public void testCreateArrayOfUint4() throws SQLException { - PreparedStatement pstmt = con.prepareStatement("SELECT ?::uint4[]"); - Long[] in = new Long[2]; - in[0] = 0L; - in[1] = 4294967295L; - pstmt.setArray(1, con.createArrayOf("uint4", in)); + try (PreparedStatement pstmt = con.prepareStatement("SELECT ?::uint4[]")) { + Integer[] in = new Integer[2]; + in[0] = 0; + in[1] = 1994967295; + pstmt.setArray(1, con.createArrayOf("uint4", in)); + try (ResultSet rs = pstmt.executeQuery()) { + Assert.assertTrue(rs.next()); + Array arr = rs.getArray(1); + Integer[] out = (Integer[]) arr.getArray(); - ResultSet rs = pstmt.executeQuery(); - Assert.assertTrue(rs.next()); - Array arr = rs.getArray(1); - Long[] out = (Long[]) arr.getArray(); - - Assert.assertEquals(2, out.length); - Assert.assertEquals(0, out[0].longValue()); - Assert.assertEquals(4294967295L, out[1].longValue()); + Assert.assertEquals(2, out.length); + Assert.assertEquals(0, out[0].intValue()); + Assert.assertEquals(1994967295, out[1].intValue()); + } + } } @Test public void testCreateArrayOfUint8() throws SQLException { - PreparedStatement pstmt = con.prepareStatement("SELECT ?::uint8[]"); - Long[] in = new Long[2]; - in[0] = 0L; - in[1] = 32458765334567556L; - pstmt.setArray(1, con.createArrayOf("uint8", in)); + try (PreparedStatement pstmt = con.prepareStatement("SELECT ?::uint8[]")) { + Long[] in = new Long[2]; + in[0] = 0L; + in[1] = 32458765334567556L; + pstmt.setArray(1, con.createArrayOf("uint8", in)); + try (ResultSet rs = pstmt.executeQuery()) { + Assert.assertTrue(rs.next()); + Array arr = rs.getArray(1); + Object[] out = (Object[]) arr.getArray(); + Long[] outLong = new Long[out.length]; + for (int i = 0; i < out.length; i++) { + outLong[i] = Long.valueOf(out[i].toString()); + } - ResultSet rs = pstmt.executeQuery(); - Assert.assertTrue(rs.next()); - Array arr = rs.getArray(1); - Object[] out = (Object[]) arr.getArray(); - Long[] outLong = new Long[out.length]; - for (int i = 0; i < out.length; i++) { - outLong[i] = Long.valueOf(out[i].toString()); + Assert.assertEquals(2, out.length); + Assert.assertEquals(0L, outLong[0].longValue()); + Assert.assertEquals(32458765334567556L, outLong[1].longValue()); + } } - - Assert.assertEquals(2, out.length); - Assert.assertEquals(0L, outLong[0].longValue()); - Assert.assertEquals(32458765334567556L, outLong[1].longValue()); } }