+ - 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
+
+ - Removed a hardwired 8K limit on query strings
+ - Added some missing org.'s in Connection that prevented
+ the use of the geometric types.
+
+ - Removed timezone in getTimestamp() methods in ResultSet.
+
- Fixed the message Makefile produces after compiling. It still said
about the old Driver class, not the new package. Spotted by
# Makefile for Java JDBC interface
#
# IDENTIFICATION
-# $Id: Makefile,v 1.22 2000/05/15 21:32:51 peter Exp $
+# $Id: Makefile,v 1.22.2.1 2000/06/15 04:12:23 momjian 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.4.2.1 2000/06/15 04:12:24 momjian 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.1 2000/04/26 05:39:32 peter Exp $
+ * $Id: Connection.java,v 1.1.2.1 2000/06/15 04:12:28 momjian 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;
- if (sql.length() > 8192)
- throw new PSQLException("postgresql.con.toolong",sql);
+ // Commented out as the backend can now handle queries
+ // larger than 8K. Peter June 6 2000
+ //if (sql.length() > 8192)
+ //throw new PSQLException("postgresql.con.toolong",sql);
try
{
pg_stream.SendChar('Q');
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);
}
}
// the full class name of the handling class.
//
private static final String defaultObjectTypes[][] = {
- {"box", "postgresql.geometric.PGbox"},
- {"circle", "postgresql.geometric.PGcircle"},
- {"line", "postgresql.geometric.PGline"},
- {"lseg", "postgresql.geometric.PGlseg"},
- {"path", "postgresql.geometric.PGpath"},
- {"point", "postgresql.geometric.PGpoint"},
- {"polygon", "postgresql.geometric.PGpolygon"},
- {"money", "postgresql.util.PGmoney"}
+ {"box", "org.postgresql.geometric.PGbox"},
+ {"circle", "org.postgresql.geometric.PGcircle"},
+ {"line", "org.postgresql.geometric.PGline"},
+ {"lseg", "org.postgresql.geometric.PGlseg"},
+ {"path", "org.postgresql.geometric.PGpath"},
+ {"point", "org.postgresql.geometric.PGpoint"},
+ {"polygon", "org.postgresql.geometric.PGpolygon"},
+ {"money", "org.postgresql.util.PGmoney"}
};
// This initialises the objectTypes hashtable
* 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.1.2.1 2000/06/15 04:12:36 momjian 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);
}
/**
if(s==null)
return null;
- SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:sszzz");
+ SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
return new Timestamp(df.parse(s).getTime());
import org.postgresql.util.*;
/**
- * $Id: Connection.java,v 1.1 2000/04/17 20:07:50 peter Exp $
+ * $Id: Connection.java,v 1.1.2.1 2000/06/15 04:12:41 momjian 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;
} catch (NumberFormatException e) {
throw new PSQLException ("postgresql.res.badbigdec",s);
}
+ if (scale==-1) return val;
try
{
return val.setScale(scale);
if(s==null)
return null;
- SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:sszzz");
+ SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
return new Timestamp(df.parse(s).getTime());
case Types.BIGINT:
return new Long(getLong(columnIndex));
case Types.NUMERIC:
- return getBigDecimal(columnIndex, ((field.mod-4) & 0xffff));
+ return getBigDecimal
+ (columnIndex, (field.mod==-1)?-1:((field.mod-4) & 0xffff));
case Types.REAL:
return new Float(getFloat(columnIndex));
case Types.DOUBLE:
public boolean absolute(int index) throws SQLException
{
- // Peter: Added because negative indices read from the end of the
- // ResultSet
- if(index<0)
- index=rows.size()+index;
-
- if (index==0 || index > rows.size())
+ // index is 1-based, but internally we use 0-based indices
+ int internalIndex;
+
+ if (index==0)
+ throw new SQLException("Cannot move to index of 0");
+
+ //if index<0, count from the end of the result set, but check
+ //to be sure that it is not beyond the first index
+ if (index<0)
+ if (index>=-rows.size())
+ internalIndex=rows.size()+index;
+ else {
+ beforeFirst();
+ return false;
+ }
+
+ //must be the case that index>0,
+ //find the correct place, assuming that
+ //the index is not too large
+ if (index<=rows.size())
+ internalIndex = index-1;
+ else {
+ afterLast();
return false;
-
- this_row = (byte [][])rows.elementAt(index);
+ }
+
+ current_row=internalIndex;
+ this_row = (byte [][])rows.elementAt(internalIndex);
return true;
}
// Peter: Implemented in 7.0
public boolean relative(int rows) throws SQLException
{
- return absolute(current_row+rows);
+ //have to add 1 since absolute expects a 1-based index
+ return absolute(current_row+1+rows);
}
public boolean rowDeleted() throws SQLException
throw org.postgresql.Driver.notImplemented();
}
-
}
projects / postgresql.git / commitdiff