Fixed Statement, so that the update count is valid when an SQL DELETE operation is done.
While fixing the update count, made it easier to get the OID of the last insert as well. Example is in example/basic.java
+Tue Jun 06 12:00:00 BST 2000 petermount@it.maidstone.gov.uk
+ - Added org/postgresql/DriverClass.java to the list of files removed
+ by make clean (it's dynamically built)
+ - Fixed Statement, so that the update count is valid when an SQL
+ DELETE operation is done.
+ - While fixing the update count, made it easier to get the OID of
+ the last insert as well. Example is in example/basic.java
+
Tue Jun 06 08:37:00 BST 2000 petermount@it.maidstone.gov.uk
- Removed a hardwired 8K limit on query strings
- Added some missing org.'s in Connection that prevented
# Makefile for Java JDBC interface
#
# IDENTIFICATION
-# $Id: Makefile,v 1.22 2000/05/15 21:32:51 peter Exp $
+# $Id: Makefile,v 1.23 2000/06/06 11:05:56 peter Exp $
#
#-------------------------------------------------------------------------
$(FIND) . -name "*.class" -exec $(RM) {} \;
$(FIND) . -name "*.html" -exec $(RM) {} \;
-$(RM) -rf stock example/corba/stock.built
- -$(RM) postgresql.jar
+ -$(RM) postgresql.jar org/postgresql/DriverClass.java
-$(RM) -rf Package-postgresql *output
#######################################################################
/**
*
- * $Id: basic.java,v 1.4 2000/04/26 05:32:00 peter Exp $
+ * $Id: basic.java,v 1.5 2000/06/06 11:05:57 peter Exp $
*
* This example tests the basic components of the JDBC driver, and shows
* how even the simplest of queries can be implemented.
st.executeUpdate("insert into basic values (2,1)");
st.executeUpdate("insert into basic values (3,1)");
+ // This shows how to get the oid of a just inserted row
+ st.executeUpdate("insert into basic values (4,1)");
+ int insertedOID = ((org.postgresql.ResultSet)st.getResultSet()).getInsertedOID();
+ System.out.println("Inserted row with oid "+insertedOID);
+
// Now change the value of b from 1 to 8
st.executeUpdate("update basic set b=8");
System.out.println("Updated "+st.getUpdateCount()+" rows");
+ // Now delete 2 rows
+ st.executeUpdate("delete from basic where a<3");
+ System.out.println("deleted "+st.getUpdateCount()+" rows");
+
// For large inserts, a PreparedStatement is more efficient, because it
// supports the idea of precompiling the SQL statement, and to store
// directly, a Java object into any column. PostgreSQL doesnt support
import org.postgresql.util.*;
/**
- * $Id: Connection.java,v 1.3 2000/06/06 07:45:07 peter Exp $
+ * $Id: Connection.java,v 1.4 2000/06/06 11:05:59 peter Exp $
*
* This abstract class is used by org.postgresql.Driver to open either the JDBC1 or
* JDBC2 versions of the Connection class.
int fqp = 0;
boolean hfr = false;
String recv_status = null, msg;
- int update_count = 1;
+ int update_count = 1;
+ int insert_oid = 0;
SQLException final_error = null;
// Commented out as the backend can now handle queries
recv_status = pg_stream.ReceiveString(8192);
// Now handle the update count correctly.
- if(recv_status.startsWith("INSERT") || recv_status.startsWith("UPDATE")) {
+ if(recv_status.startsWith("INSERT") || recv_status.startsWith("UPDATE") || recv_status.startsWith("DELETE")) {
try {
update_count = Integer.parseInt(recv_status.substring(1+recv_status.lastIndexOf(' ')));
} catch(NumberFormatException nfe) {
throw new PSQLException("postgresql.con.fathom",recv_status);
}
+ if(recv_status.startsWith("INSERT")) {
+ try {
+ insert_oid = Integer.parseInt(recv_status.substring(1+recv_status.indexOf(' '),recv_status.lastIndexOf(' ')));
+ } catch(NumberFormatException nfe) {
+ throw new PSQLException("postgresql.con.fathom",recv_status);
+ }
+ }
}
if (fields != null)
hfr = true;
if (final_error != null)
throw final_error;
- return getResultSet(this, fields, tuples, recv_status, update_count);
+ return getResultSet(this, fields, tuples, recv_status, update_count, insert_oid);
}
}
* This returns a resultset. It must be overridden, so that the correct
* version (from jdbc1 or jdbc2) are returned.
*/
- protected abstract java.sql.ResultSet getResultSet(org.postgresql.Connection conn, Field[] fields, Vector tuples, String status, int updateCount) throws SQLException;
+ protected abstract java.sql.ResultSet getResultSet(org.postgresql.Connection conn, Field[] fields, Vector tuples, String status, int updateCount,int insertOID) throws SQLException;
public abstract void close() throws SQLException;
protected Field fields[]; // The field descriptions
protected String status; // Status of the result
protected int updateCount; // How many rows did we get back?
+ protected int insertOID; // The oid of an inserted row
protected int current_row; // Our pointer to where we are at
protected byte[][] this_row; // the current row result
protected Connection connection; // the connection which we returned from
* @param updateCount the number of rows affected by the operation
* @param cursor the positioned update/delete cursor name
*/
- public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount)
+ public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount,int insertOID)
{
this.connection = conn;
this.fields = fields;
this.rows = tuples;
this.status = status;
this.updateCount = updateCount;
+ this.insertOID = insertOID;
this.this_row = null;
this.current_row = -1;
}
+
+ /**
+ * Create a new ResultSet - Note that we create ResultSets to
+ * represent the results of everything.
+ *
+ * @param fields an array of Field objects (basically, the
+ * ResultSet MetaData)
+ * @param tuples Vector of the actual data
+ * @param status the status string returned from the back end
+ * @param updateCount the number of rows affected by the operation
+ * @param cursor the positioned update/delete cursor name
+ */
+ public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount)
+ {
+ this(conn,fields,tuples,status,updateCount,0);
+ }
+
/**
* We at times need to know if the resultSet we are working
* with is the result of an UPDATE, DELETE or INSERT (in which
return fields[field-1].getOID();
}
+ /**
+ * returns the OID of the last inserted row
+ */
+ public int getInsertedOID()
+ {
+ return insertOID;
+ }
+
/**
* This is part of the JDBC API, but is required by org.postgresql.Field
*/
import org.postgresql.util.*;
/**
- * $Id: Connection.java,v 1.1 2000/04/17 20:07:48 peter Exp $
+ * $Id: Connection.java,v 1.2 2000/06/06 11:06:04 peter Exp $
*
* A Connection represents a session with a specific database. Within the
* context of a Connection, SQL statements are executed and results are
* This overides the method in org.postgresql.Connection and returns a
* ResultSet.
*/
- protected java.sql.ResultSet getResultSet(org.postgresql.Connection conn, Field[] fields, Vector tuples, String status, int updateCount) throws SQLException
+ protected java.sql.ResultSet getResultSet(org.postgresql.Connection conn, Field[] fields, Vector tuples, String status, int updateCount,int insertOID) throws SQLException
{
- return new org.postgresql.jdbc1.ResultSet((org.postgresql.jdbc1.Connection)conn,fields,tuples,status,updateCount);
+ return new org.postgresql.jdbc1.ResultSet((org.postgresql.jdbc1.Connection)conn,fields,tuples,status,updateCount,insertOID);
}
}
*/
public class ResultSet extends org.postgresql.ResultSet implements java.sql.ResultSet
{
+ /**
+ * Create a new ResultSet - Note that we create ResultSets to
+ * represent the results of everything.
+ *
+ * @param fields an array of Field objects (basically, the
+ * ResultSet MetaData)
+ * @param tuples Vector of the actual data
+ * @param status the status string returned from the back end
+ * @param updateCount the number of rows affected by the operation
+ * @param cursor the positioned update/delete cursor name
+ */
+ public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount,int insertOID)
+ {
+ super(conn,fields,tuples,status,updateCount,insertOID);
+ }
+
/**
* Create a new ResultSet - Note that we create ResultSets to
* represent the results of everything.
*/
public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount)
{
- super(conn,fields,tuples,status,updateCount);
+ super(conn,fields,tuples,status,updateCount,0);
}
/**
import org.postgresql.util.*;
/**
- * $Id: Connection.java,v 1.1 2000/04/17 20:07:50 peter Exp $
+ * $Id: Connection.java,v 1.2 2000/06/06 11:06:09 peter Exp $
*
* A Connection represents a session with a specific database. Within the
* context of a Connection, SQL statements are executed and results are
* This overides the method in org.postgresql.Connection and returns a
* ResultSet.
*/
- protected java.sql.ResultSet getResultSet(org.postgresql.Connection conn, Field[] fields, Vector tuples, String status, int updateCount) throws SQLException
+ protected java.sql.ResultSet getResultSet(org.postgresql.Connection conn, Field[] fields, Vector tuples, String status, int updateCount, int insertOID) throws SQLException
{
- return new org.postgresql.jdbc2.ResultSet((org.postgresql.jdbc2.Connection)conn,fields,tuples,status,updateCount);
+ return new org.postgresql.jdbc2.ResultSet((org.postgresql.jdbc2.Connection)conn,fields,tuples,status,updateCount,insertOID);
}
// *****************
* @param updateCount the number of rows affected by the operation
* @param cursor the positioned update/delete cursor name
*/
- public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount)
+ public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount,int insertOID)
{
- super(conn,fields,tuples,status,updateCount);
+ super(conn,fields,tuples,status,updateCount,insertOID);
}
+ /**
+ * Create a new ResultSet - Note that we create ResultSets to
+ * represent the results of everything.
+ *
+ * @param fields an array of Field objects (basically, the
+ * ResultSet MetaData)
+ * @param tuples Vector of the actual data
+ * @param status the status string returned from the back end
+ * @param updateCount the number of rows affected by the operation
+ * @param cursor the positioned update/delete cursor name
+ */
+ public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount)
+ {
+ super(conn,fields,tuples,status,updateCount,0);
+ }
+
/**
* A ResultSet is initially positioned before its first row,
* the first call to next makes the first row the current row;
throw org.postgresql.Driver.notImplemented();
}
-
}
projects / postgresql / commitdiff