diff --git a/org/postgresql/PGResultSetMetaData.java b/org/postgresql/PGResultSetMetaData.java index 56dc1c9..0b3fd77 100644 --- a/org/postgresql/PGResultSetMetaData.java +++ b/org/postgresql/PGResultSetMetaData.java @@ -9,6 +9,8 @@ package org.postgresql; import java.sql.SQLException; +import org.postgresql.core.Field; + public interface PGResultSetMetaData { @@ -36,4 +38,12 @@ public interface PGResultSetMetaData */ public String getBaseSchemaName(int column) throws SQLException; + /** + * Is a column Text or Binary? + * + * @see Field#BINARY_FORMAT + * @see Field#TEXT_FORMAT + * @since 9.4 + */ + public int getFormat(int column) throws SQLException; } diff --git a/org/postgresql/core/BaseConnection.java b/org/postgresql/core/BaseConnection.java index 6373d53..30fa883 100644 --- a/org/postgresql/core/BaseConnection.java +++ b/org/postgresql/core/BaseConnection.java @@ -154,4 +154,21 @@ public interface BaseConnection extends PGConnection, Connection * @return True for binary transfer, false for text transfer. */ public boolean binaryTransferSend(int oid); + + /** + * True if primitive types should be returned wherever possible, false for + * the default (usually object types in 8.3+ as they can represent nulls). + * If true, {@code null} values should be represented as {@code 0}. + * + * @return True if primitive types should be returned wherever possible + */ + public boolean forcePrimitives(); + + /** + * Whether we'll try to do binary transfers. This can be set via the + * binaryTransfer JDBCUrl parameter, and defaults to true. + * + * @return True if binary transfers were requested + */ + public boolean useBinaryTransfers(); } diff --git a/org/postgresql/jdbc2/AbstractJdbc2Array.java b/org/postgresql/jdbc2/AbstractJdbc2Array.java index 23bc4f7..ad71e02 100644 --- a/org/postgresql/jdbc2/AbstractJdbc2Array.java +++ b/org/postgresql/jdbc2/AbstractJdbc2Array.java @@ -14,7 +14,9 @@ import org.postgresql.util.PSQLState; import org.postgresql.util.GT; import java.io.IOException; +import java.lang.reflect.Array; import java.math.BigDecimal; +import java.nio.ByteBuffer; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Types; @@ -95,7 +97,7 @@ public abstract class AbstractJdbc2Array private AbstractJdbc2Array(BaseConnection connection, int oid) throws SQLException { this.connection = connection; this.oid = oid; - this.useObjects = connection.haveMinimumCompatibleVersion("8.3"); + this.useObjects = connection.haveMinimumCompatibleVersion("8.3") && !connection.forcePrimitives(); this.haveMinServer82 = connection.haveMinimumServerVersion("8.2"); } @@ -182,14 +184,14 @@ public abstract class AbstractJdbc2Array /*int lbound = ByteConverter.int4(fieldBytes, pos);*/ pos += 4; } if (dimensions == 0) { - return java.lang.reflect.Array.newInstance(elementOidToClass(elementOid), 0); + return Array.newInstance(elementOidToClass(elementOid), 0); } if (count > 0) { dims[0] = Math.min(count, dims[0]); } - Object arr = java.lang.reflect.Array.newInstance(elementOidToClass(elementOid), dims); + Object arr = Array.newInstance(elementOidToClass(elementOid), dims); try { - storeValues((Object[]) arr, elementOid, dims, pos, 0, index); + storeValues(arr, elementOid, dims, pos, 0, index); } catch (IOException ioe) { @@ -198,7 +200,7 @@ public abstract class AbstractJdbc2Array return arr; } - private int storeValues(final Object[] arr, int elementOid, final int[] dims, int pos, final int thisDimension, int index) throws SQLException, IOException { + private int storeValues(final Object arr, int elementOid, final int[] dims, int pos, final int thisDimension, int index) throws SQLException, IOException { if (thisDimension == dims.length - 1) { for (int i = 1; i < index; ++i) { int len = ByteConverter.int4(fieldBytes, pos); pos += 4; @@ -213,31 +215,56 @@ public abstract class AbstractJdbc2Array } switch (elementOid) { case Oid.INT2: - arr[i] = new Short(ByteConverter.int2(fieldBytes, pos)); + short asShort = ByteConverter.int2(fieldBytes, pos); + if(useObjects) { + Array.set(arr, i, Short.valueOf(asShort)); + } else { + Array.setShort(arr, i, asShort); + } break; case Oid.INT4: - arr[i] = new Integer(ByteConverter.int4(fieldBytes, pos)); + int asInt = ByteConverter.int4(fieldBytes, pos); + if(useObjects) { + Array.set(arr, i, Integer.valueOf(asInt)); + } else { + Array.setInt(arr, i, asInt); + } break; case Oid.INT8: - arr[i] = new Long(ByteConverter.int8(fieldBytes, pos)); + long asLong = ByteConverter.int8(fieldBytes, pos); + if(useObjects) { + Array.set(arr, i, Long.valueOf(asLong)); + } else { + Array.setLong(arr, i, asLong); + } break; case Oid.FLOAT4: - arr[i] = new Float(ByteConverter.float4(fieldBytes, pos)); + float asFloat = ByteConverter.float4(fieldBytes, pos); + if(useObjects) { + Array.set(arr, i, Float.valueOf(asFloat)); + } else { + Array.setFloat(arr, i, asFloat); + } break; case Oid.FLOAT8: - arr[i] = new Double(ByteConverter.float8(fieldBytes, pos)); + double asDouble = ByteConverter.float8(fieldBytes, pos); + if(useObjects) { + Array.set(arr, i, Double.valueOf(asDouble)); + } else { + Array.setDouble(arr, i, asDouble); + } break; case Oid.TEXT: case Oid.VARCHAR: Encoding encoding = connection.getEncoding(); - arr[i] = encoding.decode(fieldBytes, pos, len); + Array.set(arr, i, encoding.decode(fieldBytes, pos, len)); break; } pos += len; } } else { for (int i = 0; i < dims[thisDimension]; ++i) { - pos = storeValues((Object[]) arr[i], elementOid, dims, pos, thisDimension + 1, 0); + pos = storeValues(Array.get(arr, i), elementOid, dims, pos, thisDimension + 1, 0); } } return pos; @@ -334,19 +361,19 @@ public abstract class AbstractJdbc2Array return pos; } - private Class elementOidToClass(int oid) + private Class elementOidToClass(int oid) throws SQLException { switch (oid) { case Oid.INT2: - return Short.class; + return useObjects ? Short.class : short.class; case Oid.INT4: - return Integer.class; + return useObjects ? Integer.class : int.class; case Oid.INT8: - return Long.class; + return useObjects ? Long.class : long.class; case Oid.FLOAT4: - return Float.class; + return useObjects ? Float.class : float.class; case Oid.FLOAT8: - return Double.class; + return useObjects ? Double.class : double.class; case Oid.TEXT: case Oid.VARCHAR: return String.class; diff --git a/org/postgresql/jdbc2/AbstractJdbc2Connection.java b/org/postgresql/jdbc2/AbstractJdbc2Connection.java index 905df2b..71d0911 100644 --- a/org/postgresql/jdbc2/AbstractJdbc2Connection.java +++ b/org/postgresql/jdbc2/AbstractJdbc2Connection.java @@ -77,6 +77,9 @@ public abstract class AbstractJdbc2Connection implements BaseConnection /** Set of oids that use binary transfer when receiving from server. */ private Set useBinaryReceiveForOids; + private final boolean binaryTransfer; + private final boolean forcePrimitives; + public abstract DatabaseMetaData getMetaData() throws SQLException; // @@ -119,14 +122,8 @@ public abstract class AbstractJdbc2Connection implements BaseConnection catch (Exception e) { } - boolean binaryTransfer = true; - try - { + binaryTransfer = Boolean.valueOf(info.getProperty("binaryTransfer", "true")).booleanValue(); - } - catch (Exception e) - { - } //Print out the driver version number if (logger.logInfo()) @@ -260,6 +257,8 @@ public abstract class AbstractJdbc2Connection implements BaseConnection openStackTrace = new Throwable("Connection was created at this point:"); enableDriverManagerLogging(); } + + forcePrimitives = Boolean.parseBoolean(info.getProperty("forcePrimitives")); } private Set getOidSet(String oidList) throws PSQLException { @@ -1234,4 +1233,14 @@ public abstract class AbstractJdbc2Connection implements BaseConnection { return protoConnection.getBackendPID(); } + + @Override + public boolean forcePrimitives() { + return forcePrimitives; + } + + @Override + public boolean useBinaryTransfers() { + return binaryTransfer; + } } diff --git a/org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java b/org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java index 160f2d1..3df5147 100644 --- a/org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java +++ b/org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java @@ -12,6 +12,7 @@ import org.postgresql.core.*; import org.postgresql.util.PSQLException; import org.postgresql.util.PSQLState; import java.sql.*; + import org.postgresql.util.GT; public abstract class AbstractJdbc2ResultSetMetaData implements PGResultSetMetaData @@ -335,6 +336,17 @@ public abstract class AbstractJdbc2ResultSetMetaData implements PGResultSetMetaD } /* + * Is a column Text or Binary? + * + * @param column the first column is 1, the second is 2... + * @return column name, or "" if not applicable + * @exception SQLException if a database access error occurs + */ + public int getFormat(int column) throws SQLException { + return getField(column).getFormat(); + } + + /* * Whats is the column's data source specific type name? * * @param column the first column is 1, the second is 2, etc. diff --git a/org/postgresql/jdbc2/AbstractJdbc2Statement.java b/org/postgresql/jdbc2/AbstractJdbc2Statement.java index 7671cf6..c6b1855 100644 --- a/org/postgresql/jdbc2/AbstractJdbc2Statement.java +++ b/org/postgresql/jdbc2/AbstractJdbc2Statement.java @@ -540,7 +540,10 @@ public abstract class AbstractJdbc2Statement implements BaseStatement if (concurrency != ResultSet.CONCUR_READ_ONLY) flags |= QueryExecutor.QUERY_NO_BINARY_TRANSFER; - if (ForceBinaryTransfers) { + // we need to know what Fields are in the ResultSet so we can + // ask the database to return them in binary format (see + // sendBind in QueryExecutorImpl). + if (ForceBinaryTransfers || connection.useBinaryTransfers()) { int flags2 = flags | QueryExecutor.QUERY_DESCRIBE_ONLY; StatementResultHandler handler2 = new StatementResultHandler(); connection.getQueryExecutor().execute(queryToExecute, queryParameters, handler2, 0, 0, flags2); @@ -2617,7 +2620,7 @@ public abstract class AbstractJdbc2Statement implements BaseStatement public void setPrepareThreshold(int newThreshold) throws SQLException { checkClosed(); - if (ForceBinaryTransfers) + if (ForceBinaryTransfers || connection.useBinaryTransfers()) newThreshold = 1; if (newThreshold < 0) diff --git a/org/postgresql/test/TestUtil.java b/org/postgresql/test/TestUtil.java index 7c6c612..0042085 100644 --- a/org/postgresql/test/TestUtil.java +++ b/org/postgresql/test/TestUtil.java @@ -45,6 +45,11 @@ public class TestUtil sendBufferSize = "&sendBufferSize="+getSendBufferSize(); } + String forcePrimitives = ""; + if (getForcePrimitives() != null && !getForcePrimitives().equals("")) { + forcePrimitives = "&forcePrimitives="+getForcePrimitives(); + } + return "jdbc:postgresql://" + getServer() + ":" + getPort() + "/" @@ -54,7 +59,8 @@ public class TestUtil + protocolVersion + binaryTransfer + receiveBufferSize - + sendBufferSize; + + sendBufferSize + + forcePrimitives; } /* @@ -126,6 +132,11 @@ public class TestUtil return System.getProperty("binaryTransfer"); } + public static String getForcePrimitives() + { + return System.getProperty("forcePrimitives"); + } + public static int getSendBufferSize() { return Integer.parseInt(System.getProperty("sendBufferSize", "-1")); diff --git a/org/postgresql/test/jdbc4/Jdbc4TestSuite.java b/org/postgresql/test/jdbc4/Jdbc4TestSuite.java index 0bf8b30..fbc9455 100644 --- a/org/postgresql/test/jdbc4/Jdbc4TestSuite.java +++ b/org/postgresql/test/jdbc4/Jdbc4TestSuite.java @@ -31,6 +31,7 @@ public class Jdbc4TestSuite extends TestSuite suite.addTestSuite(ArrayTest.class); suite.addTestSuite(ConnectionTest.class); suite.addTestSuite(WrapperTest.class); + suite.addTestSuite(PrimitivesTest.class); Connection connection = TestUtil.openDB(); try diff --git a/org/postgresql/test/jdbc4/PrimitivesTest.java b/org/postgresql/test/jdbc4/PrimitivesTest.java new file mode 100644 index 0000000..b17a255 --- /dev/null +++ b/org/postgresql/test/jdbc4/PrimitivesTest.java @@ -0,0 +1,76 @@ +package org.postgresql.test.jdbc4; + +import java.sql.Array; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; + +import org.postgresql.PGResultSetMetaData; +import org.postgresql.core.Field; +import org.postgresql.jdbc2.AbstractJdbc2ResultSetMetaData; +import org.postgresql.test.TestUtil; + +import junit.framework.TestCase; + +public class PrimitivesTest extends TestCase { + + private Connection _conn; + + public PrimitivesTest(String name) { + super(name); + } + + protected void tearDown() throws Exception { + TestUtil.closeDB(_conn); + System.clearProperty("forcePrimitives"); + System.clearProperty("binaryTransfer"); + } + + public void testCreateArrayOfIntText() throws Exception { + System.setProperty("binaryTransfer", "false"); + System.setProperty("forcePrimitives", "true"); + _conn = TestUtil.openDB(); + + PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::int[]"); + Integer in[] = { 0, -1, 2 }; + pstmt.setArray(1, _conn.createArrayOf("int4", in)); + + ResultSet rs = pstmt.executeQuery(); + assertEquals(Field.TEXT_FORMAT, ((PGResultSetMetaData)rs.getMetaData()).getFormat(1)); + + assertTrue(rs.next()); + Array arr = rs.getArray(1); + int out[] = (int[]) arr.getArray(); + + assertEquals(3, out.length); + assertEquals(0, out[0]); + assertEquals(-1, out[1]); + assertEquals(2, out[2]); + } + + public void testCreateArrayOfIntBinary() throws Exception { + System.setProperty("forcePrimitives", "true"); + System.setProperty("binaryTransfer", "true"); + _conn = TestUtil.openDB(); + + PreparedStatement pstmt = _conn.prepareStatement( + "SELECT ?::int[]", + ResultSet.TYPE_FORWARD_ONLY, + ResultSet.CONCUR_READ_ONLY); + Integer in[] = { 0, -1, 2 }; + pstmt.setArray(1, _conn.createArrayOf("int4", in)); + + ResultSet rs = pstmt.executeQuery(); + assertEquals(Field.BINARY_FORMAT, ((PGResultSetMetaData)rs.getMetaData()).getFormat(1)); + + assertTrue(rs.next()); + Array arr = rs.getArray(1); + int out[] = (int[]) arr.getArray(); + + assertEquals(3, out.length); + assertEquals(0, out[0]); + assertEquals(-1, out[1]); + assertEquals(2, out[2]); + } +}