diff options
Diffstat (limited to 'src/interfaces/jdbc')
6 files changed, 162 insertions, 147 deletions
diff --git a/src/interfaces/jdbc/org/postgresql/core/QueryExecutor.java b/src/interfaces/jdbc/org/postgresql/core/QueryExecutor.java index 40c6a31d7f8..66b2c9341b2 100644 --- a/src/interfaces/jdbc/org/postgresql/core/QueryExecutor.java +++ b/src/interfaces/jdbc/org/postgresql/core/QueryExecutor.java @@ -13,24 +13,26 @@ import org.postgresql.util.PSQLException; * <p>The lifetime of a QueryExecutor object is from sending the query * until the response has been received from the backend. * - * $Id: QueryExecutor.java,v 1.13 2002/07/23 03:59:55 barry Exp $ + * $Id: QueryExecutor.java,v 1.14 2002/08/23 20:45:49 barry Exp $ */ public class QueryExecutor { - private final String sql; + private final String[] m_sqlFrags; + private final Object[] m_binds; private final java.sql.Statement statement; private final PG_Stream pg_stream; private final org.postgresql.jdbc1.AbstractJdbc1Connection connection; - public QueryExecutor(String sql, + public QueryExecutor(String[] p_sqlFrags, Object[] p_binds, java.sql.Statement statement, PG_Stream pg_stream, java.sql.Connection connection) throws SQLException { - this.sql = sql; + this.m_sqlFrags = p_sqlFrags; + this.m_binds = p_binds; this.statement = statement; this.pg_stream = pg_stream; this.connection = (org.postgresql.jdbc1.AbstractJdbc1Connection)connection; @@ -60,7 +62,7 @@ public class QueryExecutor synchronized (pg_stream) { - sendQuery(sql); + sendQuery(); int c; boolean l_endQuery = false; @@ -129,12 +131,18 @@ public class QueryExecutor /* * Send a query to the backend. */ - private void sendQuery(String query) throws SQLException + private void sendQuery() throws SQLException { try { pg_stream.SendChar('Q'); - pg_stream.Send(connection.getEncoding().encode(query)); + for (int i = 0 ; i < m_binds.length ; ++i) { + if (m_binds[i] == null) + throw new PSQLException("postgresql.prep.param", new Integer(i + 1)); + pg_stream.Send(connection.getEncoding().encode(m_sqlFrags[i])); + pg_stream.Send(connection.getEncoding().encode(m_binds[i].toString())); + } + pg_stream.Send(connection.getEncoding().encode(m_sqlFrags[m_binds.length])); pg_stream.SendChar(0); pg_stream.flush(); diff --git a/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Connection.java b/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Connection.java index 7f6afd44c2d..3c93e540319 100644 --- a/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Connection.java +++ b/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Connection.java @@ -13,7 +13,7 @@ import org.postgresql.largeobject.LargeObjectManager; import org.postgresql.util.*; -/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Connection.java,v 1.4 2002/08/16 19:34:57 davec Exp $ +/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Connection.java,v 1.5 2002/08/23 20:45:49 barry Exp $ * This class defines methods of the jdbc1 specification. This class is * extended by org.postgresql.jdbc2.AbstractJdbc2Connection which adds the jdbc2 * methods. The real Connection class (for jdbc1) is org.postgresql.jdbc1.Jdbc1Connection @@ -426,7 +426,26 @@ public abstract class AbstractJdbc1Connection implements org.postgresql.PGConnec */ public java.sql.ResultSet ExecSQL(String sql, java.sql.Statement stat) throws SQLException { - return new QueryExecutor(sql, stat, pg_stream, (java.sql.Connection)this).execute(); + return new QueryExecutor(new String[] {sql}, EMPTY_OBJECT_ARRAY, stat, pg_stream, (java.sql.Connection)this).execute(); + } + private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0]; + + /* + * Send a query to the backend. Returns one of the ResultSet + * objects. + * + * <B>Note:</B> there does not seem to be any method currently + * in existance to return the update count. + * + * @param p_sqlFragmentss the SQL statement parts to be executed + * @param p_binds the SQL bind values + * @param stat The Statement associated with this query (may be null) + * @return a ResultSet holding the results + * @exception SQLException if a database error occurs + */ + public java.sql.ResultSet ExecSQL(String[] p_sqlFragments, Object[] p_binds, java.sql.Statement stat) throws SQLException + { + return new QueryExecutor(p_sqlFragments, p_binds, stat, pg_stream, (java.sql.Connection)this).execute(); } /* diff --git a/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java b/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java index fc532fcc8be..5f410f99951 100644 --- a/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java +++ b/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1Statement.java @@ -8,7 +8,7 @@ import java.util.Vector; import org.postgresql.largeobject.*; import org.postgresql.util.*; -/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Statement.java,v 1.4 2002/08/16 17:51:38 barry Exp $ +/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Statement.java,v 1.5 2002/08/23 20:45:49 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 @@ -28,12 +28,12 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme /** Timeout (in seconds) for a query (not used) */ protected int timeout = 0; - protected boolean escapeProcessing = true; + protected boolean replaceProcessingEnabled = true; /** The current results */ protected java.sql.ResultSet result = null; - // Static variables for parsing SQL when escapeProcessing is true. + // Static variables for parsing SQL when replaceProcessing is true. private static final short IN_SQLCODE = 0; private static final short IN_STRING = 1; private static final short BACKSLASH = 2; @@ -43,9 +43,8 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme private StringBuffer sbuf = new StringBuffer(32); //Used by the preparedstatement style methods - protected String sql; - protected String[] templateStrings; - protected String[] inStrings; + protected String[] m_sqlFragments; + protected Object[] m_binds = new Object[0]; //Used by the callablestatement style methods private static final String JDBC_SYNTAX = "{[? =] call <some_function> ([? [,?]*]) }"; @@ -68,42 +67,46 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme this.connection = connection; } - public AbstractJdbc1Statement (AbstractJdbc1Connection connection, String sql) throws SQLException + public AbstractJdbc1Statement (AbstractJdbc1Connection connection, String p_sql) throws SQLException { - this.sql = sql; this.connection = connection; - parseSqlStmt(); // this allows Callable stmt to override + parseSqlStmt(p_sql); // this allows Callable stmt to override } - protected void parseSqlStmt () throws SQLException { - if (this instanceof CallableStatement) { - modifyJdbcCall(); + protected void parseSqlStmt (String p_sql) throws SQLException { + String l_sql = p_sql; + + l_sql = replaceProcessing(l_sql); + + if (this instanceof CallableStatement) { + l_sql = modifyJdbcCall(l_sql); } Vector v = new Vector(); boolean inQuotes = false; int lastParmEnd = 0, i; - for (i = 0; i < sql.length(); ++i) + for (i = 0; i < l_sql.length(); ++i) { - int c = sql.charAt(i); + int c = l_sql.charAt(i); if (c == '\'') inQuotes = !inQuotes; if (c == '?' && !inQuotes) { - v.addElement(sql.substring (lastParmEnd, i)); + v.addElement(l_sql.substring (lastParmEnd, i)); lastParmEnd = i + 1; } } - v.addElement(sql.substring (lastParmEnd, sql.length())); + v.addElement(l_sql.substring (lastParmEnd, l_sql.length())); - templateStrings = new String[v.size()]; - inStrings = new String[v.size() - 1]; + m_sqlFragments = new String[v.size()]; + m_binds = new String[v.size() - 1]; + //BJL why if binds is new??? clearParameters(); - for (i = 0 ; i < templateStrings.length; ++i) - templateStrings[i] = (String)v.elementAt(i); + for (i = 0 ; i < m_sqlFragments.length; ++i) + m_sqlFragments[i] = (String)v.elementAt(i); } @@ -114,14 +117,11 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme * @return a ResulSet that contains the data produced by the query * @exception SQLException if a database access error occurs */ - public java.sql.ResultSet executeQuery(String sql) throws SQLException + public java.sql.ResultSet executeQuery(String p_sql) throws SQLException { - this.execute(sql); - while (result != null && !((AbstractJdbc1ResultSet)result).reallyResultSet()) - result = ((AbstractJdbc1ResultSet)result).getNext(); - if (result == null) - throw new PSQLException("postgresql.stat.noresult"); - return result; + String l_sql = replaceProcessing(p_sql); + m_sqlFragments = new String[] {l_sql}; + return executeQuery(); } /* @@ -133,7 +133,12 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme */ public java.sql.ResultSet executeQuery() throws SQLException { - return executeQuery(compileQuery()); + this.execute(); + while (result != null && !((AbstractJdbc1ResultSet)result).reallyResultSet()) + result = ((AbstractJdbc1ResultSet)result).getNext(); + if (result == null) + throw new PSQLException("postgresql.stat.noresult"); + return result; } /* @@ -145,12 +150,11 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme * @return either a row count, or 0 for SQL commands * @exception SQLException if a database access error occurs */ - public int executeUpdate(String sql) throws SQLException + public int executeUpdate(String p_sql) throws SQLException { - this.execute(sql); - if (((AbstractJdbc1ResultSet)result).reallyResultSet()) - throw new PSQLException("postgresql.stat.result"); - return this.getUpdateCount(); + String l_sql = replaceProcessing(p_sql); + m_sqlFragments = new String[] {l_sql}; + return executeUpdate(); } /* @@ -164,7 +168,10 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme */ public int executeUpdate() throws SQLException { - return executeUpdate(compileQuery()); + this.execute(); + if (((AbstractJdbc1ResultSet)result).reallyResultSet()) + throw new PSQLException("postgresql.stat.result"); + return this.getUpdateCount(); } /* @@ -178,10 +185,30 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme * an update count or there are no more results * @exception SQLException if a database access error occurs */ - public boolean execute(String sql) throws SQLException + public boolean execute(String p_sql) throws SQLException + { + String l_sql = replaceProcessing(p_sql); + m_sqlFragments = new String[] {l_sql}; + return execute(); + } + + /* + * Some prepared statements return multiple results; the execute method + * handles these complex statements as well as the simpler form of + * statements handled by executeQuery and executeUpdate + * + * @return true if the next result is a ResultSet; false if it is an + * * update count or there are no more results + * @exception SQLException if a database access error occurs + */ + public boolean execute() throws SQLException { - if (escapeProcessing) - sql = escapeSQL(sql); + if (isFunction && !returnTypeSet) + throw new PSQLException("postgresql.call.noreturntype"); + if (isFunction) { // set entry 1 to dummy entry.. + m_binds[0] = ""; // dummy entry which ensured that no one overrode + // and calls to setXXX (2,..) really went to first arg in a function call.. + } // New in 7.1, if we have a previous resultset then force it to close // This brings us nearer to compliance, and helps memory management. @@ -195,7 +222,7 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme // New in 7.1, pass Statement so that ExecSQL can customise to it - result = ((AbstractJdbc1Connection)connection).ExecSQL(sql, (java.sql.Statement)this); + result = ((AbstractJdbc1Connection)connection).ExecSQL(m_sqlFragments, m_binds, (java.sql.Statement)this); //If we are executing a callable statement function set the return data if (isFunction) { @@ -217,20 +244,6 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme } /* - * Some prepared statements return multiple results; the execute method - * handles these complex statements as well as the simpler form of - * statements handled by executeQuery and executeUpdate - * - * @return true if the next result is a ResultSet; false if it is an - * * update count or there are no more results - * @exception SQLException if a database access error occurs - */ - public boolean execute() throws SQLException - { - return execute(compileQuery()); - } - - /* * setCursorName defines the SQL cursor name that will be used by * subsequent execute methods. This name can then be used in SQL * positioned update/delete statements to identify the current row @@ -336,7 +349,7 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme */ public void setEscapeProcessing(boolean enable) throws SQLException { - escapeProcessing = enable; + replaceProcessingEnabled = enable; } /* @@ -494,18 +507,19 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme * So, something like "select * from x where d={d '2001-10-09'}" would * return "select * from x where d= '2001-10-09'". */ - protected static String escapeSQL(String sql) + protected String replaceProcessing(String p_sql) { + if (replaceProcessingEnabled) { // Since escape codes can only appear in SQL CODE, we keep track // of if we enter a string or not. - StringBuffer newsql = new StringBuffer(sql.length()); + StringBuffer newsql = new StringBuffer(p_sql.length()); short state = IN_SQLCODE; int i = -1; - int len = sql.length(); + int len = p_sql.length(); while (++i < len) { - char c = sql.charAt(i); + char c = p_sql.charAt(i); switch (state) { case IN_SQLCODE: @@ -514,7 +528,7 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme else if (c == '{') // start of an escape code? if (i + 1 < len) { - char next = sql.charAt(i + 1); + char next = p_sql.charAt(i + 1); if (next == 'd') { state = ESC_TIMEDATE; @@ -524,7 +538,7 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme else if (next == 't') { state = ESC_TIMEDATE; - i += (i + 2 < len && sql.charAt(i + 2) == 's') ? 2 : 1; + i += (i + 2 < len && p_sql.charAt(i + 2) == 's') ? 2 : 1; break; } } @@ -556,6 +570,9 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme } return newsql.toString(); + } else { + return p_sql; + } } /* @@ -1113,8 +1130,8 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme { int i; - for (i = 0 ; i < inStrings.length ; i++) - inStrings[i] = null; + for (i = 0 ; i < m_binds.length ; i++) + m_binds[i] = null; } /* @@ -1532,8 +1549,6 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme /* * Returns the SQL statement with the current template values * substituted. - * NB: This is identical to compileQuery() except instead of throwing - * SQLException if a parameter is null, it places ? instead. */ public String toString() { @@ -1542,15 +1557,15 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme sbuf.setLength(0); int i; - for (i = 0 ; i < inStrings.length ; ++i) + for (i = 0 ; i < m_binds.length ; ++i) { - if (inStrings[i] == null) + if (m_binds[i] == null) sbuf.append( '?' ); else - sbuf.append (templateStrings[i]); - sbuf.append (inStrings[i]); + sbuf.append (m_sqlFragments[i]); + sbuf.append (m_binds[i]); } - sbuf.append(templateStrings[inStrings.length]); + sbuf.append(m_sqlFragments[m_binds.length]); return sbuf.toString(); } } @@ -1566,39 +1581,11 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme */ protected void set(int paramIndex, String s) throws SQLException { - if (paramIndex < 1 || paramIndex > inStrings.length) + if (paramIndex < 1 || paramIndex > m_binds.length) throw new PSQLException("postgresql.prep.range"); if (paramIndex == 1 && isFunction) // need to registerOut instead throw new PSQLException ("postgresql.call.funcover"); - inStrings[paramIndex - 1] = s; - } - - /* - * Helper - this compiles the SQL query from the various parameters - * This is identical to toString() except it throws an exception if a - * parameter is unused. - */ - protected synchronized String compileQuery() - throws SQLException - { - sbuf.setLength(0); - int i; - - if (isFunction && !returnTypeSet) - throw new PSQLException("postgresql.call.noreturntype"); - if (isFunction) { // set entry 1 to dummy entry.. - inStrings[0] = ""; // dummy entry which ensured that no one overrode - // and calls to setXXX (2,..) really went to first arg in a function call.. - } - - for (i = 0 ; i < inStrings.length ; ++i) - { - if (inStrings[i] == null) - throw new PSQLException("postgresql.prep.param", new Integer(i + 1)); - sbuf.append (templateStrings[i]).append (inStrings[i]); - } - sbuf.append(templateStrings[inStrings.length]); - return sbuf.toString(); + m_binds[paramIndex - 1] = s; } /* @@ -1630,26 +1617,27 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme * select <some_function> (?, [?, ...]) as result * */ - private void modifyJdbcCall() throws SQLException { + private String modifyJdbcCall(String p_sql) throws SQLException { // syntax checking is not complete only a few basics :( - originalSql = sql; // save for error msgs.. - int index = sql.indexOf ("="); // is implied func or proc? + originalSql = p_sql; // save for error msgs.. + String l_sql = p_sql; + int index = l_sql.indexOf ("="); // is implied func or proc? boolean isValid = true; if (index != -1) { isFunction = true; - isValid = sql.indexOf ("?") < index; // ? before = + isValid = l_sql.indexOf ("?") < index; // ? before = } - sql = sql.trim (); - if (sql.startsWith ("{") && sql.endsWith ("}")) { - sql = sql.substring (1, sql.length() -1); + l_sql = l_sql.trim (); + if (l_sql.startsWith ("{") && l_sql.endsWith ("}")) { + l_sql = l_sql.substring (1, l_sql.length() -1); } else isValid = false; - index = sql.indexOf ("call"); + index = l_sql.indexOf ("call"); if (index == -1 || !isValid) throw new PSQLException ("postgresql.call.malformed", - new Object[]{sql, JDBC_SYNTAX}); - sql = sql.replace ('{', ' '); // replace these characters - sql = sql.replace ('}', ' '); - sql = sql.replace (';', ' '); + new Object[]{l_sql, JDBC_SYNTAX}); + l_sql = l_sql.replace ('{', ' '); // replace these characters + l_sql = l_sql.replace ('}', ' '); + l_sql = l_sql.replace (';', ' '); // this removes the 'call' string and also puts a hidden '?' // at the front of the line for functions, this will @@ -1658,9 +1646,10 @@ public abstract class AbstractJdbc1Statement implements org.postgresql.PGStateme // value that is not needed by the postgres syntax. But to make // sure that the parameter numbers are the same as in the original // sql we add a dummy parameter in this case - sql = (isFunction ? "?" : "") + sql.substring (index + 4); + l_sql = (isFunction ? "?" : "") + l_sql.substring (index + 4); - sql = "select " + sql + " as " + RESULT_COLUMN + ";"; + l_sql = "select " + l_sql + " as " + RESULT_COLUMN + ";"; + return l_sql; } /** helperfunction for the getXXX calls to check isFunction and index == 1 diff --git a/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java b/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java index 3b493de2f4d..43e71062ab9 100644 --- a/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java +++ b/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java @@ -15,15 +15,13 @@ import org.postgresql.util.PGbytea; import org.postgresql.util.PSQLException; -/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2ResultSet.java,v 1.4 2002/08/14 20:35:39 barry Exp $ +/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2ResultSet.java,v 1.5 2002/08/23 20:45:49 barry Exp $ * This class defines methods of the jdbc2 specification. This class extends * org.postgresql.jdbc1.AbstractJdbc1ResultSet which provides the jdbc1 * methods. The real Statement class (for jdbc2) is org.postgresql.jdbc2.Jdbc2ResultSet */ public abstract class AbstractJdbc2ResultSet extends org.postgresql.jdbc1.AbstractJdbc1ResultSet { - protected String sqlQuery = null; - //needed for updateable result set support protected boolean updateable = false; protected boolean doingUpdates = false; @@ -1254,7 +1252,9 @@ public abstract class AbstractJdbc2ResultSet extends org.postgresql.jdbc1.Abstra public void parseQuery() { - StringTokenizer st = new StringTokenizer(sqlQuery, " \r\t"); + String[] l_sqlFragments = ((AbstractJdbc2Statement)statement).getSqlFragments(); + String l_sql = l_sqlFragments[0]; + StringTokenizer st = new StringTokenizer(l_sql, " \r\t"); boolean tableFound = false, tablesChecked = false; String name = ""; @@ -1326,11 +1326,6 @@ public abstract class AbstractJdbc2ResultSet extends org.postgresql.jdbc1.Abstra } - public void setSQLQuery(String sqlQuery) { - this.sqlQuery = sqlQuery; - } - - private class PrimaryKey { int index; // where in the result set is this primaryKey String name; // what is the columnName of this primary Key diff --git a/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2Statement.java b/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2Statement.java index d8d16985ad1..457f36e9413 100644 --- a/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2Statement.java +++ b/src/interfaces/jdbc/org/postgresql/jdbc2/AbstractJdbc2Statement.java @@ -8,7 +8,7 @@ import java.util.Vector; import org.postgresql.largeobject.*; import org.postgresql.util.PSQLException; -/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2Statement.java,v 1.3 2002/07/25 22:45:28 barry Exp $ +/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2Statement.java,v 1.4 2002/08/23 20:45:49 barry Exp $ * This class defines methods of the jdbc2 specification. This class extends * org.postgresql.jdbc1.AbstractJdbc1Statement which provides the jdbc1 * methods. The real Statement class (for jdbc2) is org.postgresql.jdbc2.Jdbc2Statement @@ -43,32 +43,28 @@ public abstract class AbstractJdbc2Statement extends org.postgresql.jdbc1.Abstra * an update count or there are no more results * @exception SQLException if a database access error occurs */ - public boolean execute(String sql) throws SQLException + public boolean execute() throws SQLException { - boolean l_return = super.execute(sql); + boolean l_return = super.execute(); //Now do the jdbc2 specific stuff //required for ResultSet.getStatement() to work and updateable resultsets ((AbstractJdbc2ResultSet)result).setStatement((Statement)this); - // Added this so that the Updateable resultset knows the query that gave this - ((AbstractJdbc2ResultSet)result).setSQLQuery(sql); - return l_return; } // ** JDBC 2 Extensions ** - public void addBatch(String sql) throws SQLException + public void addBatch(String p_sql) throws SQLException { if (batch == null) batch = new Vector(); - batch.addElement(sql); + batch.addElement(p_sql); } public void clearBatch() throws SQLException { - if (batch != null) - batch.removeAllElements(); + batch = null; } public int[] executeBatch() throws SQLException @@ -155,7 +151,7 @@ public abstract class AbstractJdbc2Statement extends org.postgresql.jdbc1.Abstra public void addBatch() throws SQLException { - addBatch(compileQuery()); + addBatch(this.toString()); } public java.sql.ResultSetMetaData getMetaData() throws SQLException @@ -388,4 +384,9 @@ public abstract class AbstractJdbc2Statement extends org.postgresql.jdbc1.Abstra } + //This is needed by AbstractJdbc2ResultSet to determine if the query is updateable or not + protected String[] getSqlFragments() { + return m_sqlFragments; + } + } diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataTest.java index 85a6afe60bb..cb7d036a77f 100644 --- a/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataTest.java +++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataTest.java @@ -9,7 +9,7 @@ import java.sql.*; * * PS: Do you know how difficult it is to type on a train? ;-) * - * $Id: DatabaseMetaDataTest.java,v 1.11 2002/08/14 20:35:40 barry Exp $ + * $Id: DatabaseMetaDataTest.java,v 1.12 2002/08/23 20:45:49 barry Exp $ */ public class DatabaseMetaDataTest extends TestCase @@ -102,7 +102,10 @@ public class DatabaseMetaDataTest extends TestCase assertTrue(dbmd.supportsMinimumSQLGrammar()); assertTrue(!dbmd.supportsCoreSQLGrammar()); assertTrue(!dbmd.supportsExtendedSQLGrammar()); - assertTrue(dbmd.supportsANSI92EntryLevelSQL()); + if (((org.postgresql.jdbc1.AbstractJdbc1Connection)con).haveMinimumServerVersion("7.3")) + assertTrue(dbmd.supportsANSI92EntryLevelSQL()); + else + assertTrue(!dbmd.supportsANSI92EntryLevelSQL()); assertTrue(!dbmd.supportsANSI92IntermediateSQL()); assertTrue(!dbmd.supportsANSI92FullSQL()); @@ -426,12 +429,12 @@ public class DatabaseMetaDataTest extends TestCase assertNotNull(dbmd); assertTrue(dbmd.getDatabaseProductName().equals("PostgreSQL")); - //The test below doesn't make sense to me, it tests that + //The test below doesn't make sense to me, it tests that //the version of the driver = the version of the database it is connected to - //since the driver should be backwardly compatible this test is commented out + //since the driver should be backwardly compatible this test is commented out //assertTrue(dbmd.getDatabaseProductVersion().startsWith( - // Integer.toString(pc.getDriver().getMajorVersion()) - // + "." + // Integer.toString(pc.getDriver().getMajorVersion()) + // + "." // + Integer.toString(pc.getDriver().getMinorVersion()))); assertTrue(dbmd.getDriverName().equals("PostgreSQL Native Driver")); |