import java.sql.*;
import org.postgresql.*;
import org.postgresql.util.PSQLException;
+import org.postgresql.jdbc1.AbstractJdbc1Connection;
+import org.postgresql.jdbc1.AbstractJdbc1ResultSet;
+import org.postgresql.jdbc1.AbstractJdbc1Statement;
/*
* Executes a query on the backend.
*
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.17 2002/11/14 05:35:45 barry Exp $
+ * $Id: QueryExecutor.java,v 1.18 2003/02/04 09:20:08 barry Exp $
*/
public class QueryExecutor
{
+ //This version of execute does not take an existing result set, but
+ //creates a new one for the results of the query
+ public static ResultSet execute (String[] p_sqlFrags,
+ Object[] p_binds,
+ java.sql.Statement statement)
+ throws SQLException
+ {
+ QueryExecutor qe = new QueryExecutor();
+ qe.m_sqlFrags = p_sqlFrags;
+ qe.m_binds = p_binds;
+ qe.statement = statement;
+ if (statement != null)
+ qe.maxRows = statement.getMaxRows();
+ else
+ qe.maxRows = 0;
- 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;
+ qe.connection = (AbstractJdbc1Connection)((AbstractJdbc1Statement)statement).getPGConnection();
+ qe.pg_stream = qe.connection.getPGStream();
- public QueryExecutor(String[] p_sqlFrags, Object[] p_binds,
- java.sql.Statement statement,
- PG_Stream pg_stream,
- java.sql.Connection connection)
+ return qe.execute();
+ }
+
+ //This version of execute reuses an existing result set for the query
+ //results, this is used when a result set is backed by a cursor and
+ //more results are fetched
+ public static void execute (String[] p_sqlFrags,
+ Object[] p_binds,
+ java.sql.ResultSet rs)
throws SQLException
{
- 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;
-
- if (statement != null)
- maxRows = statement.getMaxRows();
+ QueryExecutor qe = new QueryExecutor();
+ qe.m_sqlFrags = p_sqlFrags;
+ qe.m_binds = p_binds;
+ qe.rs = rs;
+ qe.statement = (java.sql.Statement)((AbstractJdbc1ResultSet)qe.rs).getPGStatement();
+ if (qe.statement != null)
+ qe.maxRows = qe.statement.getMaxRows();
else
- maxRows = 0;
+ qe.maxRows = 0;
+
+ qe.connection = (AbstractJdbc1Connection)((AbstractJdbc1Statement)qe.statement).getPGConnection();
+ qe.pg_stream = qe.connection.getPGStream();
+
+ qe.execute();
}
+
+ private QueryExecutor ()
+ {
+ }
+
+ private String[] m_sqlFrags;
+ private Object[] m_binds;
+ private java.sql.Statement statement;
+ private java.sql.ResultSet rs;
+
+ private AbstractJdbc1Connection connection;
+ private PG_Stream pg_stream;
+
private Field[] fields = null;
private Vector tuples = new Vector();
private boolean binaryCursor = false;
private long insert_oid = 0;
private int maxRows;
+
/*
* Execute a query on the backend.
+ *
*/
- public java.sql.ResultSet execute() throws SQLException
+ private java.sql.ResultSet execute() throws SQLException
{
StringBuffer errorMessage = null;
if ( errorMessage != null )
throw new SQLException( errorMessage.toString() );
- return connection.getResultSet(statement, fields, tuples, status, update_count, insert_oid, binaryCursor);
+
+ //if an existing result set was passed in reuse it, else
+ //create a new one
+ if (rs != null)
+ {
+ ((org.postgresql.jdbc1.AbstractJdbc1ResultSet)rs).reInit(fields, tuples, status, update_count, insert_oid, binaryCursor);
+ }
+ else
+ {
+ rs = ((AbstractJdbc1Statement)statement).createResultSet(fields, tuples, status, update_count, insert_oid, binaryCursor);
+ }
+ return rs;
}
}
for (int i = 0 ; i < m_binds.length ; ++i)
{
if (m_binds[i] == null)
- throw new PSQLException("postgresql.prep.param", new Integer(i + 1));
+ throw new PSQLException("postgresql.prep.param (" + i + ")", 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();
import org.postgresql.util.*;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Connection.java,v 1.13 2002/11/14 05:35:45 barry Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Connection.java,v 1.14 2003/02/04 09:20:08 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
public abstract class AbstractJdbc1Connection implements org.postgresql.PGConnection
{
// This is the network stream associated with this connection
- public PG_Stream pg_stream;
+ private PG_Stream pg_stream;
+ public PG_Stream getPGStream() {
+ return pg_stream;
+ }
+
protected String PG_HOST;
protected int PG_PORT;
protected String PG_USER;
public abstract java.sql.Statement createStatement() throws SQLException;
-
/*
* This method actually opens the connection. It is called by Driver.
*
// Set datestyle and fetch db encoding in a single call, to avoid making
// more than one round trip to the backend during connection startup.
- java.sql.ResultSet resultSet =
- ExecSQL("set datestyle to 'ISO'; select version(), " + encodingQuery + ";");
+ java.sql.ResultSet resultSet
+ = execSQL("set datestyle to 'ISO'; select version(), " + encodingQuery + ";");
+
if (! resultSet.next())
{
throw new PSQLException("postgresql.con.failed", "failed getting backend encoding");
if (haveMinimumServerVersion("7.3"))
{
java.sql.ResultSet acRset =
- ExecSQL("set client_encoding = 'UNICODE'; show autocommit");
+ execSQL("set client_encoding = 'UNICODE'; show autocommit");
//set encoding to be unicode
encoding = Encoding.getEncoding("UNICODE", null);
//to make the setting permanent
if (acRset.getString(1).equals("off"))
{
- ExecSQL("set autocommit = on; commit;");
+ execSQL("set autocommit = on; commit;");
}
}
return this_driver;
}
- // These methods used to be in the main Connection implementation. As they
- // are common to all implementations (JDBC1 or 2), they are placed here.
- // This should make it easy to maintain the two specifications.
-
- public abstract java.sql.ResultSet getResultSet(Statement statement, org.postgresql.Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException;
-
- public abstract java.sql.ResultSet getResultSet(Statement statement, org.postgresql.Field[] fields, Vector tuples, String status, int updateCount) throws SQLException;
/*
* This adds a warning to the warning chain.
//}
}
- /*
- * Send a query to the backend. Returns one of the ResultSet
- * objects.
- *
- * Note: there does not seem to be any method currently
- * in existance to return the update count.
- *
- * @param sql the SQL statement to be executed
- * @return a ResultSet holding the results
- * @exception SQLException if a database error occurs
+ /** Simple query execution.
*/
- public java.sql.ResultSet ExecSQL(String sql) throws SQLException
+ public java.sql.ResultSet execSQL (String s) throws SQLException
{
- return ExecSQL(sql, null);
- }
-
- /*
- * Send a query to the backend. Returns one of the ResultSet
- * objects.
- *
- * Note: there does not seem to be any method currently
- * in existance to return the update count.
- *
- * @param sql the SQL statement to be executed
- * @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 sql, java.sql.Statement stat) throws SQLException
- {
- if (isClosed())
- {
- throw new PSQLException("postgresql.con.closed");
- }
- 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.
- *
- * Note: 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
- {
- if (isClosed())
- {
- throw new PSQLException("postgresql.con.closed");
- }
- return new QueryExecutor(p_sqlFragments, p_binds, stat, pg_stream, (java.sql.Connection)this).execute();
+ final Object[] nullarr = new Object[0];
+ java.sql.Statement stat = createStatement();
+ return QueryExecutor.execute(new String[] { s },
+ nullarr,
+ stat);
}
/*
//We do the select to ensure a transaction is in process
//before we do the commit to avoid warning messages
//from issuing a commit without a transaction in process
- ExecSQL("select 1; commit; set autocommit = on;");
+ execSQL("select 1; commit; set autocommit = on;");
}
else
{
- ExecSQL("end");
+ execSQL("end");
}
}
else
{
if (haveMinimumServerVersion("7.3"))
{
- ExecSQL("set autocommit = off; " + getIsolationLevelSQL());
+ execSQL("set autocommit = off; " + getIsolationLevelSQL());
}
else if (haveMinimumServerVersion("7.1"))
{
- ExecSQL("begin;" + getIsolationLevelSQL());
+ execSQL("begin;" + getIsolationLevelSQL());
}
else
{
- ExecSQL("begin");
- ExecSQL(getIsolationLevelSQL());
+ execSQL("begin");
+ execSQL(getIsolationLevelSQL());
}
}
this.autoCommit = autoCommit;
return ;
if (haveMinimumServerVersion("7.3"))
{
- ExecSQL("commit; " + getIsolationLevelSQL());
+ execSQL("commit; " + getIsolationLevelSQL());
}
else if (haveMinimumServerVersion("7.1"))
{
- ExecSQL("commit;begin;" + getIsolationLevelSQL());
+ execSQL("commit;begin;" + getIsolationLevelSQL());
}
else
{
- ExecSQL("commit");
- ExecSQL("begin");
- ExecSQL(getIsolationLevelSQL());
+ execSQL("commit");
+ execSQL("begin");
+ execSQL(getIsolationLevelSQL());
}
}
//we don't automatically start a transaction
//but let the server functionality automatically start
//one when the first statement is executed
- ExecSQL("rollback; " + getIsolationLevelSQL());
+ execSQL("rollback; " + getIsolationLevelSQL());
}
else if (haveMinimumServerVersion("7.1"))
{
- ExecSQL("rollback; begin;" + getIsolationLevelSQL());
+ execSQL("rollback; begin;" + getIsolationLevelSQL());
}
else
{
- ExecSQL("rollback");
- ExecSQL("begin");
- ExecSQL(getIsolationLevelSQL());
+ execSQL("rollback");
+ execSQL("begin");
+ execSQL(getIsolationLevelSQL());
}
}
String sql = "show transaction isolation level";
String level = null;
if (haveMinimumServerVersion("7.3")) {
- ResultSet rs = ExecSQL(sql);
+ ResultSet rs = execSQL(sql);
if (rs.next()) {
level = rs.getString(1);
}
rs.close();
} else {
clearWarnings();
- ExecSQL(sql);
+ execSQL(sql);
SQLWarning warning = getWarnings();
if (warning != null)
{
new Integer(isolationLevel));
}
}
- ExecSQL(isolationLevelSQL);
+ execSQL(isolationLevelSQL);
}
/*
} else {
sql = "SELECT typname FROM pg_type WHERE oid = " +oid;
}
- ResultSet result = ExecSQL(sql);
+ ResultSet result = execSQL(sql);
if (((AbstractJdbc1ResultSet)result).getColumnCount() != 1 || ((AbstractJdbc1ResultSet)result).getTupleCount() != 1) {
throw new PSQLException("postgresql.unexpected");
}
} else {
sql = "SELECT oid FROM pg_type WHERE typname='" + typeName + "'";
}
- ResultSet result = ExecSQL(sql);
+ ResultSet result = execSQL(sql);
if (((AbstractJdbc1ResultSet)result).getColumnCount() != 1 || ((AbstractJdbc1ResultSet)result).getTupleCount() != 1)
throw new PSQLException("postgresql.unexpected");
result.next();
* Tip: keep these grouped together by the Types. value
*/
private static final int jdbc1Typei[] = {
- Types.SMALLINT,
- Types.INTEGER, Types.INTEGER,
- Types.BIGINT,
- Types.DOUBLE, Types.DOUBLE,
- Types.NUMERIC,
- Types.REAL,
- Types.DOUBLE,
- Types.CHAR, Types.CHAR, Types.CHAR, Types.CHAR, Types.CHAR, Types.CHAR,
- Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
- Types.BINARY,
- Types.BIT,
- Types.DATE,
- Types.TIME,
- Types.TIMESTAMP, Types.TIMESTAMP, Types.TIMESTAMP
- };
+ Types.SMALLINT,
+ Types.INTEGER, Types.INTEGER,
+ Types.BIGINT,
+ Types.DOUBLE, Types.DOUBLE,
+ Types.NUMERIC,
+ Types.REAL,
+ Types.DOUBLE,
+ Types.CHAR, Types.CHAR, Types.CHAR, Types.CHAR, Types.CHAR, Types.CHAR,
+ Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+ Types.BINARY,
+ Types.BIT,
+ Types.DATE,
+ Types.TIME,
+ Types.TIMESTAMP, Types.TIMESTAMP, Types.TIMESTAMP
+ };
//Methods to support postgres notifications
public void addNotification(org.postgresql.PGNotification p_notification)
}
rs.close();
- return connection.getResultSet(null, f, v, "OK", 1);
+ return ((AbstractJdbc1Statement)connection.createStatement()).createResultSet(f, v, "OK", 1, 0, false);
}
/*
tuple[0] = types[i].getBytes();
v.addElement(tuple);
}
- return connection.getResultSet(null, f, v, "OK", 1);
+
+ return ((AbstractJdbc1Statement)connection.createStatement()).createResultSet(f, v, "OK", 1, 0, false);
}
/*
}
rs.close();
- return connection.getResultSet(null, f, v, "OK", 1);
+ return ((AbstractJdbc1Statement)connection.createStatement()).createResultSet(f, v, "OK", 1, 0, false);
}
/*
}
}
rs.close();
- return connection.getResultSet(null, f, v, "OK", 1);
+
+ return ((AbstractJdbc1Statement)connection.createStatement()).createResultSet(f, v, "OK", 1, 0, false);
}
/*
}
rs.close();
- return connection.getResultSet(null, f, v, "OK", 1);
+ return ((AbstractJdbc1Statement)connection.createStatement()).createResultSet(f, v, "OK", 1, 0, false);
}
private static void sortStringArray(String s[]) {
tuple[7] = Integer.toString(java.sql.DatabaseMetaData.bestRowNotPseudo).getBytes();
v.addElement(tuple);
}
- return connection.getResultSet(null, f, v, "OK", 1);
+
+ return ((AbstractJdbc1Statement)connection.createStatement()).createResultSet(f, v, "OK", 1, 0, false);
}
/*
/* Perhaps we should check that the given
* catalog.schema.table actually exists. -KJ
*/
- return connection.getResultSet(null, f, v, "OK", 1);
+ return ((AbstractJdbc1Statement)connection.createStatement()).createResultSet(f, v, "OK", 1, 0, false);
}
/*
tuples.addElement(tuple);
}
- return connection.getResultSet(null, f, tuples, "OK", 1);
+ return ((AbstractJdbc1Statement)connection.createStatement()).createResultSet(f, tuples, "OK", 1, 0, false);
}
/*
v.addElement(tuple);
}
rs.close();
- return connection.getResultSet(null, f, v, "OK", 1);
+
+ return ((AbstractJdbc1Statement)connection.createStatement()).createResultSet(f, v, "OK", 1, 0, false);
}
/*
import org.postgresql.util.PGbytea;
import org.postgresql.util.PSQLException;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1ResultSet.java,v 1.8 2003/01/14 09:13:51 barry Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1ResultSet.java,v 1.9 2003/02/04 09:20:08 barry Exp $
* This class defines methods of the jdbc1 specification. This class is
* extended by org.postgresql.jdbc2.AbstractJdbc2ResultSet which adds the jdbc2
* methods. The real ResultSet class (for jdbc1) is org.postgresql.jdbc1.Jdbc1ResultSet
*/
-public abstract class AbstractJdbc1ResultSet
+public abstract class AbstractJdbc1ResultSet
{
protected Vector rows; // The results
protected Statement statement;
+
+ public org.postgresql.PGStatement getPGStatement() {
+ return (org.postgresql.PGStatement) statement;
+ }
+
protected Field fields[]; // The field descriptions
protected String status; // Status of the result
protected boolean binaryCursor = false; // is the data binary or Strings
public byte[][] rowBuffer = null;
- public AbstractJdbc1ResultSet(org.postgresql.PGConnection conn, Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
+ public AbstractJdbc1ResultSet(Statement statement,
+ Field[] fields,
+ Vector tuples,
+ String status,
+ int updateCount,
+ long insertOID,
+ boolean binaryCursor)
{
- this.connection = conn;
+ this.connection = ((org.postgresql.jdbc1.AbstractJdbc1Statement)statement).getPGConnection();
this.statement = statement;
this.fields = fields;
this.rows = tuples;
this.status = status;
this.updateCount = updateCount;
+
this.insertOID = insertOID;
this.this_row = null;
this.current_row = -1;
}
+ //method to reinitialize a result set with more data
+ public void reInit (Field[] fields, Vector tuples, String status,
+ int updateCount, long insertOID, boolean binaryCursor)
+ {
+ this.fields = fields;
+ // on a reinit the size of this indicates how many we pulled
+ // back. If it's 0 then the res set has ended.
+ this.rows = tuples;
+ this.status = status;
+ this.updateCount = updateCount;
+ this.insertOID = insertOID;
+ this.this_row = null;
+ this.current_row = -1;
+ this.binaryCursor = binaryCursor;
+ }
+
+
public boolean next() throws SQLException
{
if (rows == null)
throw new PSQLException("postgresql.con.closed");
if (++current_row >= rows.size())
- return false;
+ {
+ int fetchSize = ((AbstractJdbc1Statement)statement).fetchSize;
+ // Must be false if we weren't batching.
+ if (fetchSize == 0)
+ return false;
+ // Use the ref to the statement to get
+ // the details we need to do another cursor
+ // query - it will use reinit() to repopulate this
+ // with the right data.
+ String[] sql = new String[1];
+ String[] binds = new String[0];
+ // Is this the correct query???
+ String cursorName = ((AbstractJdbc1Statement)statement).m_statementName;
+ sql[0] = "FETCH FORWARD " + fetchSize + " FROM " + cursorName;
+ org.postgresql.core.QueryExecutor.execute(sql,
+ binds,
+ (java.sql.ResultSet)this);
+
+ // Test the new rows array.
+ if (rows.size() == 0)
+ return false;
+ // Otherwise reset the counter and let it go on...
+ current_row = 0;
+ }
this_row = (byte [][])rows.elementAt(current_row);
import org.postgresql.largeobject.*;
import org.postgresql.util.*;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Statement.java,v 1.14 2002/11/20 07:34:32 barry Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1Statement.java,v 1.15 2003/02/04 09:20:08 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
// The connection who created us
protected AbstractJdbc1Connection connection;
+ public org.postgresql.PGConnection getPGConnection() {
+ return connection;
+ }
+
/** The warnings chain. */
protected SQLWarning warnings = null;
/** Maximum number of rows to return, 0 = unlimited */
protected int maxrows = 0;
+ /** Number of rows to get in a batch. */
+ protected int fetchSize = 0;
+
/** Timeout (in seconds) for a query (not used) */
protected int timeout = 0;
private String[] m_origSqlFragments;
private String[] m_executeSqlFragments;
protected Object[] m_binds = new Object[0];
+
protected String[] m_bindTypes = new String[0];
- private String m_statementName = null;
+ protected String m_statementName = null;
+
private boolean m_useServerPrepare = false;
private static int m_preparedCount = 1;
protected Object callResult;
+ public abstract java.sql.ResultSet createResultSet(org.postgresql.Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException;
public AbstractJdbc1Statement (AbstractJdbc1Connection connection)
{
}
-
+
/*
* Execute a SQL statement that retruns a single ResultSet
*
m_binds = new Object[0];
//If we have already created a server prepared statement, we need
//to deallocate the existing one
- if (m_statementName != null) {
- ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
- m_statementName = null;
- m_origSqlFragments = null;
- m_executeSqlFragments = null;
+ if (m_statementName != null)
+ {
+ try
+ {
+ ((AbstractJdbc1Connection)connection).execSQL("DEALLOCATE " + m_statementName);
+ }
+ catch (Exception e)
+ {
+ }
+ finally
+ {
+ m_statementName = null;
+ m_origSqlFragments = null;
+ m_executeSqlFragments = null;
+ }
}
return executeQuery();
}
*/
public java.sql.ResultSet executeQuery() throws SQLException
{
- this.execute();
+ if (fetchSize > 0)
+ this.executeWithCursor();
+ else
+ this.execute();
+
while (result != null && !((AbstractJdbc1ResultSet)result).reallyResultSet())
result = ((AbstractJdbc1ResultSet)result).getNext();
if (result == null)
//If we have already created a server prepared statement, we need
//to deallocate the existing one
if (m_statementName != null) {
- ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
+ ((AbstractJdbc1Connection)connection).execSQL("DEALLOCATE " + m_statementName);
m_statementName = null;
m_origSqlFragments = null;
m_executeSqlFragments = null;
//If we have already created a server prepared statement, we need
//to deallocate the existing one
if (m_statementName != null) {
- ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
+ ((AbstractJdbc1Connection)connection).execSQL("DEALLOCATE " + m_statementName);
m_statementName = null;
m_origSqlFragments = null;
m_executeSqlFragments = null;
}
// New in 7.1, pass Statement so that ExecSQL can customise to it
- result = ((AbstractJdbc1Connection)connection).ExecSQL(m_sqlFragments, m_binds, (java.sql.Statement)this);
+ result = org.postgresql.core.QueryExecutor.execute(m_sqlFragments,
+ m_binds,
+ (java.sql.Statement)this);
//If we are executing a callable statement function set the return data
if (isFunction)
}
}
+ /** version of execute which converts the query to a cursor.
+ */
+ public boolean executeWithCursor() throws SQLException
+ {
+ 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
+ m_bindTypes[0] = PG_TEXT;
+ // 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.
+ // Internal stuff will call ExecSQL directly, bypassing this.
+ if (result != null)
+ {
+ java.sql.ResultSet rs = getResultSet();
+ if (rs != null)
+ rs.close();
+ }
+
+ // I've pretty much ignored server prepared statements... can declare and prepare be
+ // used together?
+ // It's trivial to change this: you just have to resolve this issue
+ // of how to work out whether there's a function call. If there isn't then the first
+ // element of the array must be the bit that you extend to become the cursor
+ // decleration.
+ // The last thing that can go wrong is when the user supplies a cursor statement
+ // directly: the translation takes no account of that. I think we should just look
+ // for declare and stop the translation if we find it.
+
+ // The first thing to do is transform the statement text into the cursor form.
+ String[] origSqlFragments = m_sqlFragments;
+ m_sqlFragments = new String[origSqlFragments.length];
+ System.arraycopy(origSqlFragments, 0, m_sqlFragments, 0, origSqlFragments.length);
+ // Pinch the prepared count for our own nefarious purposes.
+ m_statementName = "JDBC_CURS_" + m_preparedCount++;
+ // The static bit to prepend to all querys.
+ String cursDecl = "BEGIN; DECLARE " + m_statementName + " CURSOR FOR ";
+ String endCurs = " FETCH FORWARD " + fetchSize + " FROM " + m_statementName + ";";
+
+ // Add the real query to the curs decleration.
+ // This is the bit that really makes the presumption about
+ // m_sqlFragments not being a function call.
+ if (m_sqlFragments.length < 1)
+ m_sqlFragments[0] = cursDecl + "SELECT NULL;";
+
+ else if (m_sqlFragments.length < 2)
+ {
+ if (m_sqlFragments[0].endsWith(";"))
+ m_sqlFragments[0] = cursDecl + m_sqlFragments[0] + endCurs;
+ else
+ m_sqlFragments[0] = cursDecl + m_sqlFragments[0] + ";" + endCurs;
+ }
+ else
+ {
+ m_sqlFragments[0] = cursDecl + m_sqlFragments[0];
+ if (m_sqlFragments[m_sqlFragments.length - 1].endsWith(";"))
+ m_sqlFragments[m_sqlFragments.length - 1] += endCurs;
+ else
+ m_sqlFragments[m_sqlFragments.length - 1] += (";" + endCurs);
+ }
+
+ result = org.postgresql.core.QueryExecutor.execute(m_sqlFragments,
+ m_binds,
+ (java.sql.Statement)this);
+
+ //If we are executing a callable statement function set the return data
+ if (isFunction)
+ {
+ if (!((AbstractJdbc1ResultSet)result).reallyResultSet())
+ throw new PSQLException("postgresql.call.noreturnval");
+ if (!result.next ())
+ throw new PSQLException ("postgresql.call.noreturnval");
+ callResult = result.getObject(1);
+ int columnType = result.getMetaData().getColumnType(1);
+ if (columnType != functionReturnType)
+ {
+ Object[] arr =
+ { "java.sql.Types=" + columnType,
+ "java.sql.Types=" + functionReturnType
+ };
+ throw new PSQLException ("postgresql.call.wrongrtntype",arr);
+ }
+ result.close ();
+ return true;
+ }
+ else
+ {
+ return (result != null && ((AbstractJdbc1ResultSet)result).reallyResultSet());
+ }
+ }
+
+
/*
* setCursorName defines the SQL cursor name that will be used by
* subsequent execute methods. This name can then be used in SQL
// If using server prepared statements deallocate them
if (m_useServerPrepare && m_statementName != null) {
- ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
+ ((AbstractJdbc1Connection)connection).execSQL("DEALLOCATE " + m_statementName);
}
// Disasociate it from us (For Garbage Collection)
*/
public byte[] getBytes(int parameterIndex) throws SQLException
{
- checkIndex (parameterIndex, Types.VARBINARY, "Bytes");
+ checkIndex (parameterIndex, Types.VARBINARY, Types.BINARY, "Bytes");
return ((byte [])callResult);
}
String l_sql = p_sql;
int index = l_sql.indexOf ("="); // is implied func or proc?
boolean isValid = true;
- if (index != -1)
+ if (index > -1)
{
isFunction = true;
isValid = l_sql.indexOf ("?") < index; // ? before =
// sure that the parameter numbers are the same as in the original
// sql we add a dummy parameter in this case
l_sql = (isFunction ? "?" : "") + l_sql.substring (index + 4);
-
l_sql = "select " + l_sql + " as " + RESULT_COLUMN + ";";
return l_sql;
}
+ /** helperfunction for the getXXX calls to check isFunction and index == 1
+ * Compare BOTH type fields against the return type.
+ */
+ protected void checkIndex (int parameterIndex, int type1, int type2, String getName)
+ throws SQLException
+ {
+ checkIndex (parameterIndex);
+ if (type1 != this.testReturn && type2 != this.testReturn)
+ throw new PSQLException("postgresql.call.wrongget",
+ new Object[]{"java.sql.Types=" + testReturn,
+ getName,
+ "java.sql.Types=" + type1});
+ }
+
/** helperfunction for the getXXX calls to check isFunction and index == 1
*/
protected void checkIndex (int parameterIndex, int type, String getName)
checkIndex (parameterIndex);
if (type != this.testReturn)
throw new PSQLException("postgresql.call.wrongget",
- new Object[]{"java.sql.Types=" + testReturn,
- getName,
- "java.sql.Types=" + type});
+ new Object[]{"java.sql.Types=" + testReturn,
+ getName,
+ "java.sql.Types=" + type});
}
+
/** helperfunction for the getXXX calls to check isFunction and index == 1
* @param parameterIndex index of getXXX (index)
* check to make sure is a function and index == 1
//If turning server prepared statements off deallocate statement
//and reset statement name
if (m_useServerPrepare != flag && !flag)
- ((AbstractJdbc1Connection)connection).ExecSQL("DEALLOCATE " + m_statementName);
+ ((AbstractJdbc1Connection)connection).execSQL("DEALLOCATE " + m_statementName);
m_statementName = null;
m_useServerPrepare = flag;
} else {
{
super(connection, sql);
}
+
+ public java.sql.ResultSet createResultSet (org.postgresql.Field[] fields, java.util.Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
+ {
+ return new Jdbc1ResultSet(this, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ }
}
import org.postgresql.Field;
import org.postgresql.util.PSQLException;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/Jdbc1Connection.java,v 1.5 2002/09/06 21:23:06 momjian Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/Jdbc1Connection.java,v 1.6 2003/02/04 09:20:10 barry Exp $
* This class implements the java.sql.Connection interface for JDBC1.
* However most of the implementation is really done in
* org.postgresql.jdbc1.AbstractJdbc1Connection
return metadata;
}
- public java.sql.ResultSet getResultSet(java.sql.Statement stat, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
- {
- return new Jdbc1ResultSet(this, stat, fields, tuples, status, updateCount, insertOID, binaryCursor);
- }
-
- public java.sql.ResultSet getResultSet(java.sql.Statement stat, Field[] fields, Vector tuples, String status, int updateCount) throws SQLException
- {
- return new Jdbc1ResultSet(this, stat, fields, tuples, status, updateCount, 0, false);
- }
-
}
super(connection, sql);
}
+ public java.sql.ResultSet createResultSet (org.postgresql.Field[] fields, java.util.Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
+ {
+ return new Jdbc1ResultSet(this, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ }
}
import java.util.Vector;
import org.postgresql.Field;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/Jdbc1ResultSet.java,v 1.4 2002/09/06 21:23:06 momjian Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/Jdbc1ResultSet.java,v 1.5 2003/02/04 09:20:10 barry Exp $
* This class implements the java.sql.ResultSet interface for JDBC1.
* However most of the implementation is really done in
* org.postgresql.jdbc1.AbstractJdbc1ResultSet
public class Jdbc1ResultSet extends org.postgresql.jdbc1.AbstractJdbc1ResultSet implements java.sql.ResultSet
{
- public Jdbc1ResultSet(Jdbc1Connection conn, Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
+ public Jdbc1ResultSet(Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
{
- super(conn, statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ super(statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
}
public java.sql.ResultSetMetaData getMetaData() throws SQLException
import java.sql.*;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/Jdbc1Statement.java,v 1.3 2002/09/06 21:23:06 momjian Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/Jdbc1Statement.java,v 1.4 2003/02/04 09:20:10 barry Exp $
* This class implements the java.sql.Statement interface for JDBC1.
* However most of the implementation is really done in
* org.postgresql.jdbc1.AbstractJdbc1Statement
super(c);
}
+ public java.sql.ResultSet createResultSet (org.postgresql.Field[] fields, java.util.Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
+ {
+ return new Jdbc1ResultSet(this, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ }
}
import java.sql.*;
import org.postgresql.util.PSQLException;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2Connection.java,v 1.2 2002/09/06 21:23:06 momjian Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2Connection.java,v 1.3 2003/02/04 09:20:10 barry Exp $
* This class defines methods of the jdbc2 specification. This class extends
* org.postgresql.jdbc1.AbstractJdbc1Connection which provides the jdbc1
* methods. The real Connection class (for jdbc2) is org.postgresql.jdbc2.Jdbc2Connection
* The current type mappings
*/
protected java.util.Map typemap;
-
+
public java.sql.Statement createStatement() throws SQLException
{
// The spec says default of TYPE_FORWARD_ONLY but everyone is used to
import org.postgresql.util.PSQLException;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2ResultSet.java,v 1.12 2003/01/23 18:49:22 davec Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2ResultSet.java,v 1.13 2003/02/04 09:20:10 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
protected PreparedStatement deleteStatement = null;
private PreparedStatement selectStatement = null;
-
-
- public AbstractJdbc2ResultSet(org.postgresql.PGConnection conn, Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
+
+ public AbstractJdbc2ResultSet(Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
{
- super (conn, statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ super (statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
}
public java.net.URL getURL(int columnIndex) throws SQLException
public int getFetchSize() throws SQLException
{
- // In this implementation we return the entire result set, so
- // here return the number of rows we have. Sub-classes can return a proper
- // value
+ // Returning the current batch size seems the right thing to do.
return rows.size();
}
}
updateValue(columnIndex, theData);
-
}
throw new PSQLException("postgresql.updateable.ioerror" + ie);
}
updateValue(columnIndex, theData);
-
}
import org.postgresql.largeobject.*;
import org.postgresql.util.PSQLException;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2Statement.java,v 1.10 2002/11/20 20:37:53 barry Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/AbstractJdbc2Statement.java,v 1.11 2003/02/04 09:20:10 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
public int getFetchSize() throws SQLException
{
- return 0;
+ return super.fetchSize;
}
public int getResultSetConcurrency() throws SQLException
public void setFetchDirection(int direction) throws SQLException
{
- throw org.postgresql.Driver.notImplemented();
+ // I don't think this should happen, since it's a hint it should just
+ // fail quietly.
+ // throw org.postgresql.Driver.notImplemented();
}
public void setFetchSize(int rows) throws SQLException
{
- throw org.postgresql.Driver.notImplemented();
+ super.fetchSize = rows;
}
public void setResultSetConcurrency(int value) throws SQLException
default:
throw org.postgresql.Driver.notImplemented();
}
- return ((AbstractJdbc2Connection)conn).getResultSet(null, fields, rows, "OK", 1 );
+ java.sql.Statement stat = ((AbstractJdbc2Connection)conn).createStatement();
+ return ((AbstractJdbc2Statement)stat).createResultSet(fields, rows, "OK", 1, 0, false);
}
public String toString()
super(connection, sql);
}
+ public java.sql.ResultSet createResultSet (org.postgresql.Field[] fields, java.util.Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
+ {
+ return new Jdbc2ResultSet(this, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ }
}
import java.util.Hashtable;
import org.postgresql.Field;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/Jdbc2Connection.java,v 1.5 2002/09/06 21:23:06 momjian Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/Jdbc2Connection.java,v 1.6 2003/02/04 09:20:10 barry Exp $
* This class implements the java.sql.Connection interface for JDBC2.
* However most of the implementation is really done in
* org.postgresql.jdbc2.AbstractJdbc2Connection or one of it's parents
return metadata;
}
- public java.sql.ResultSet getResultSet(Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
- {
- return new Jdbc2ResultSet(this, statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
- }
-
- public java.sql.ResultSet getResultSet(Statement statement, Field[] fields, Vector tuples, String status, int updateCount) throws SQLException
- {
- return new Jdbc2ResultSet(this, statement, fields, tuples, status, updateCount, 0, false);
- }
-
-
}
super(connection, sql);
}
+ public java.sql.ResultSet createResultSet (org.postgresql.Field[] fields, java.util.Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
+ {
+ return new Jdbc2ResultSet(this, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ }
}
import java.util.Vector;
import org.postgresql.Field;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/Jdbc2ResultSet.java,v 1.6 2002/09/11 05:38:45 barry Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/Jdbc2ResultSet.java,v 1.7 2003/02/04 09:20:10 barry Exp $
* This class implements the java.sql.ResultSet interface for JDBC2.
* However most of the implementation is really done in
* org.postgresql.jdbc2.AbstractJdbc2ResultSet or one of it's parents
public class Jdbc2ResultSet extends org.postgresql.jdbc2.AbstractJdbc2ResultSet implements java.sql.ResultSet
{
- public Jdbc2ResultSet(Jdbc2Connection conn, Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
+ public Jdbc2ResultSet(Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
{
- super(conn, statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ super(statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
}
public java.sql.ResultSetMetaData getMetaData() throws SQLException
import java.sql.*;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/Jdbc2Statement.java,v 1.3 2002/09/06 21:23:06 momjian Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Attic/Jdbc2Statement.java,v 1.4 2003/02/04 09:20:10 barry Exp $
* This class implements the java.sql.Statement interface for JDBC2.
* However most of the implementation is really done in
* org.postgresql.jdbc2.AbstractJdbc2Statement or one of it's parents
super(c);
}
+ public java.sql.ResultSet createResultSet (org.postgresql.Field[] fields, java.util.Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
+ {
+ return new Jdbc2ResultSet(this, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ }
}
import java.sql.*;
import java.util.Vector;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc3/Attic/AbstractJdbc3ResultSet.java,v 1.2 2002/09/06 21:23:06 momjian Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc3/Attic/AbstractJdbc3ResultSet.java,v 1.3 2003/02/04 09:20:10 barry Exp $
* This class defines methods of the jdbc3 specification. This class extends
* org.postgresql.jdbc2.AbstractJdbc2ResultSet which provides the jdbc2
* methods. The real Statement class (for jdbc3) is org.postgresql.jdbc3.Jdbc3ResultSet
public abstract class AbstractJdbc3ResultSet extends org.postgresql.jdbc2.AbstractJdbc2ResultSet
{
- public AbstractJdbc3ResultSet(org.postgresql.PGConnection conn, Statement statement, org.postgresql.Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
+ public AbstractJdbc3ResultSet(Statement statement, org.postgresql.Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
{
- super (conn, statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ super (statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
}
/**
super(connection, sql);
}
+ public java.sql.ResultSet createResultSet (org.postgresql.Field[] fields, java.util.Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
+ {
+ return new Jdbc3ResultSet(this, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ }
+
}
import java.util.Hashtable;
import org.postgresql.Field;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc3/Attic/Jdbc3Connection.java,v 1.2 2002/09/06 21:23:06 momjian Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc3/Attic/Jdbc3Connection.java,v 1.3 2003/02/04 09:20:10 barry Exp $
* This class implements the java.sql.Connection interface for JDBC3.
* However most of the implementation is really done in
* org.postgresql.jdbc3.AbstractJdbc3Connection or one of it's parents
return metadata;
}
- public java.sql.ResultSet getResultSet(Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
- {
- return new Jdbc3ResultSet(this, statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
- }
-
- public java.sql.ResultSet getResultSet(Statement statement, Field[] fields, Vector tuples, String status, int updateCount) throws SQLException
- {
- return new Jdbc3ResultSet(this, statement, fields, tuples, status, updateCount, 0, false);
- }
-
}
-
-
super(connection, sql);
}
+ public java.sql.ResultSet createResultSet (org.postgresql.Field[] fields, java.util.Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
+ {
+ return new Jdbc3ResultSet(this, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ }
+
}
import java.util.Vector;
import org.postgresql.Field;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc3/Attic/Jdbc3ResultSet.java,v 1.3 2002/09/11 05:38:45 barry Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc3/Attic/Jdbc3ResultSet.java,v 1.4 2003/02/04 09:20:11 barry Exp $
* This class implements the java.sql.ResultSet interface for JDBC3.
* However most of the implementation is really done in
* org.postgresql.jdbc3.AbstractJdbc3ResultSet or one of it's parents
public class Jdbc3ResultSet extends org.postgresql.jdbc3.AbstractJdbc3ResultSet implements java.sql.ResultSet
{
- public Jdbc3ResultSet(Jdbc3Connection conn, Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
+ public Jdbc3ResultSet(Statement statement, Field[] fields, Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor)
{
- super(conn, statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ super(statement, fields, tuples, status, updateCount, insertOID, binaryCursor);
}
public java.sql.ResultSetMetaData getMetaData() throws SQLException
import java.sql.*;
-/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc3/Attic/Jdbc3Statement.java,v 1.2 2002/09/06 21:23:06 momjian Exp $
+/* $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc3/Attic/Jdbc3Statement.java,v 1.3 2003/02/04 09:20:11 barry Exp $
* This class implements the java.sql.Statement interface for JDBC3.
* However most of the implementation is really done in
* org.postgresql.jdbc3.AbstractJdbc3Statement or one of it's parents
super(c);
}
+ public java.sql.ResultSet createResultSet (org.postgresql.Field[] fields, java.util.Vector tuples, String status, int updateCount, long insertOID, boolean binaryCursor) throws SQLException
+ {
+ return new Jdbc3ResultSet(this, fields, tuples, status, updateCount, insertOID, binaryCursor);
+ }
+
}
if (Driver.logDebug)
Driver.debug("Serialize.store: " + sb.toString() );
- ResultSet rs = ((org.postgresql.jdbc1.AbstractJdbc1Connection)conn).ExecSQL(sb.toString());
+ ResultSet rs = ((org.postgresql.jdbc1.AbstractJdbc1Connection)conn).execSQL(sb.toString());
// fetch the OID for returning
if (update)
projects / postgresql.git / commitdiff