Applied patch from Oliver Jowett to clean up some instances where the wrong

type was being reported for PREPAREs.

 Modified Files:
 	jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java
 	jdbc/org/postgresql/test/jdbc2/ServerPreparedStmtTest.java

diff --git a/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java b/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java
index 93133c51d6f1b6c58e0367a9ac058e9b4b7ce6bc..1e23fa51afe779468acefaa4c7ad8962b37f8ca6 100644 (file)
--- a/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java
+++ b/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java
@@ -26,7 +26,7 @@ import java.sql.Timestamp;
 import java.sql.Types;
 import java.util.Vector;
 
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Statement.java,v 1.37 2003/09/17 05:07:37 barry Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Statement.java,v 1.38 2003/09/18 04:14:27 barry Exp $
  * This class defines methods of the jdbc1 specification.  This class is
  * extended by org.postgresql.jdbc2.AbstractJdbc2Statement which adds the jdbc2
  * methods.  The real Statement class (for jdbc1) is org.postgresql.jdbc1.Jdbc1Statement
@@ -893,6 +893,9 @@ public abstract class AbstractJdbc1Statement implements BaseStatement
            case Types.TIMESTAMP:
                l_pgType = PG_TIMESTAMPTZ;
                break;
+           case Types.BIT:
+               l_pgType = PG_BOOLEAN;
+               break;
            case Types.BINARY:
            case Types.VARBINARY:
            case Types.LONGVARBINARY:
@@ -930,7 +933,7 @@ public abstract class AbstractJdbc1Statement implements BaseStatement
     */
    public void setByte(int parameterIndex, byte x) throws SQLException
    {
-       bind(parameterIndex, Integer.toString(x), PG_TEXT);
+       bind(parameterIndex, Integer.toString(x), PG_INT2);
    }
 
    /*
@@ -1457,6 +1460,21 @@ public abstract class AbstractJdbc1Statement implements BaseStatement
        }
    }
 
+   // Helper method that extracts numeric values from an arbitary Object.
+   private String numericValueOf(Object x)
+   {
+       if (x instanceof Boolean)
+           return ((Boolean)x).booleanValue() ? "1" :"0";
+       else if (x instanceof Integer || x instanceof Long || 
+                x instanceof Double || x instanceof Short ||
+                x instanceof Number || x instanceof Float)
+           return x.toString();
+       else
+           //ensure the value is a valid numeric value to avoid
+           //sql injection attacks
+           return new BigDecimal(x.toString()).toString();
+   }       
+
    /*
     * Set the value of a parameter using an object; use the java.lang
     * equivalent objects for integral values.
@@ -1486,35 +1504,25 @@ public abstract class AbstractJdbc1Statement implements BaseStatement
        switch (targetSqlType)
        {
            case Types.INTEGER:
-               if (x instanceof Boolean)
-                   bind(parameterIndex,((Boolean)x).booleanValue() ? "1" :"0", PG_BOOLEAN);
-               else if (x instanceof Integer || x instanceof Long || 
-                   x instanceof Double || x instanceof Short ||
-                   x instanceof Number || x instanceof Float )
-                   bind(parameterIndex, x.toString(), PG_INTEGER);
-               else
-                   //ensure the value is a valid numeric value to avoid
-                   //sql injection attacks
-                   bind(parameterIndex, new BigDecimal(x.toString()).toString(), PG_INTEGER);
+               bind(parameterIndex, numericValueOf(x), PG_INTEGER);
                break;
            case Types.TINYINT:
            case Types.SMALLINT:
+               bind(parameterIndex, numericValueOf(x), PG_INT2);
+               break;
            case Types.BIGINT:
+               bind(parameterIndex, numericValueOf(x), PG_INT8);
+               break;
            case Types.REAL:
            case Types.FLOAT:
+               bind(parameterIndex, numericValueOf(x), PG_FLOAT);
+               break;
            case Types.DOUBLE:
+               bind(parameterIndex, numericValueOf(x), PG_DOUBLE);
+               break;
            case Types.DECIMAL:
            case Types.NUMERIC:
-               if (x instanceof Boolean)
-                   bind(parameterIndex, ((Boolean)x).booleanValue() ? "1" : "0", PG_BOOLEAN);
-               else if (x instanceof Integer || x instanceof Long || 
-                   x instanceof Double || x instanceof Short ||
-                   x instanceof Number || x instanceof Float )
-                   bind(parameterIndex, x.toString(), PG_NUMERIC);
-               else
-                   //ensure the value is a valid numeric value to avoid
-                   //sql injection attacks
-                   bind(parameterIndex, new BigDecimal(x.toString()).toString(), PG_NUMERIC);
+               bind(parameterIndex, numericValueOf(x), PG_NUMERIC);
                break;
            case Types.CHAR:
            case Types.VARCHAR:
@@ -1559,7 +1567,7 @@ public abstract class AbstractJdbc1Statement implements BaseStatement
                }
                else if (x instanceof Number)
                {
-                   bind(parameterIndex, ((Number)x).intValue()==1 ? "'1'" : "'0'", PG_BOOLEAN);
+                   bind(parameterIndex, ((Number)x).intValue()!=0 ? "'1'" : "'0'", PG_BOOLEAN);
                }
                else
                {
@@ -1572,7 +1580,10 @@ public abstract class AbstractJdbc1Statement implements BaseStatement
                setObject(parameterIndex, x);
                break;
            case Types.OTHER:
-               setString(parameterIndex, ((PGobject)x).getValue(), PG_TEXT);
+               if (x instanceof PGobject)
+                   setString(parameterIndex, ((PGobject)x).getValue(), ((PGobject)x).getType());
+               else
+                   throw new PSQLException("postgresql.prep.type", PSQLState.INVALID_PARAMETER_TYPE);
                break;
            default:
                throw new PSQLException("postgresql.prep.type", PSQLState.INVALID_PARAMETER_TYPE);

diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/ServerPreparedStmtTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/ServerPreparedStmtTest.java
index ea819b3633382a6d6f89d4b36a4392805f86252d..aa5831385fc017e256ec42afdb173f8f8bb40411 100644 (file)
--- a/src/interfaces/jdbc/org/postgresql/test/jdbc2/ServerPreparedStmtTest.java
+++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/ServerPreparedStmtTest.java
@@ -26,14 +26,14 @@ public class ServerPreparedStmtTest extends TestCase
        con = TestUtil.openDB();
        Statement stmt = con.createStatement();
 
-       TestUtil.createTable(con, "testsps", "id integer");
+       TestUtil.createTable(con, "testsps", "id integer, value boolean");
 
-       stmt.executeUpdate("INSERT INTO testsps VALUES (1)");
-       stmt.executeUpdate("INSERT INTO testsps VALUES (2)");
-       stmt.executeUpdate("INSERT INTO testsps VALUES (3)");
-       stmt.executeUpdate("INSERT INTO testsps VALUES (4)");
-       stmt.executeUpdate("INSERT INTO testsps VALUES (6)");
-       stmt.executeUpdate("INSERT INTO testsps VALUES (9)");
+       stmt.executeUpdate("INSERT INTO testsps VALUES (1,'t')");
+       stmt.executeUpdate("INSERT INTO testsps VALUES (2,'t')");
+       stmt.executeUpdate("INSERT INTO testsps VALUES (3,'t')");
+       stmt.executeUpdate("INSERT INTO testsps VALUES (4,'t')");
+       stmt.executeUpdate("INSERT INTO testsps VALUES (6,'t')");
+       stmt.executeUpdate("INSERT INTO testsps VALUES (9,'f')");
 
        stmt.close();
    }
@@ -125,6 +125,60 @@ public class ServerPreparedStmtTest extends TestCase
        pstmt.close();
    }
 
+   // Verify we can bind booleans-as-objects ok.
+   public void testBooleanObjectBind() throws Exception
+   {
+       PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE value = ?");
+        ((PGStatement)pstmt).setUseServerPrepare(true);
+        if (TestUtil.haveMinimumServerVersion(con,"7.3")) {
+           assertTrue(((PGStatement)pstmt).isUseServerPrepare());
+       } else {
+           assertTrue(!((PGStatement)pstmt).isUseServerPrepare());
+       }
+
+        pstmt.setObject(1, new Boolean(false), java.sql.Types.BIT);
+       ResultSet rs = pstmt.executeQuery();
+       assertTrue(rs.next());
+        assertEquals(9, rs.getInt(1));
+        rs.close();
+   }
+
+   // Verify we can bind booleans-as-integers ok.
+   public void testBooleanIntegerBind() throws Exception
+   {
+       PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE id = ?");
+        ((PGStatement)pstmt).setUseServerPrepare(true);
+        if (TestUtil.haveMinimumServerVersion(con,"7.3")) {
+           assertTrue(((PGStatement)pstmt).isUseServerPrepare());
+       } else {
+           assertTrue(!((PGStatement)pstmt).isUseServerPrepare());
+       }
+
+        pstmt.setObject(1, new Boolean(true), java.sql.Types.INTEGER);
+       ResultSet rs = pstmt.executeQuery();
+       assertTrue(rs.next());
+        assertEquals(1, rs.getInt(1));
+        rs.close();
+   }
+
+   // Verify we can bind booleans-as-native-types ok.
+   public void testBooleanBind() throws Exception
+   {
+       PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE value = ?");
+        ((PGStatement)pstmt).setUseServerPrepare(true);
+        if (TestUtil.haveMinimumServerVersion(con,"7.3")) {
+           assertTrue(((PGStatement)pstmt).isUseServerPrepare());
+       } else {
+           assertTrue(!((PGStatement)pstmt).isUseServerPrepare());
+       }
+
+        pstmt.setBoolean(1, false);
+       ResultSet rs = pstmt.executeQuery();
+       assertTrue(rs.next());
+        assertEquals(9, rs.getInt(1));
+        rs.close();
+   }
+
    public void testPreparedStatementsWithBinds() throws Exception
    {
        PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE id = ? or id = ?");