Hello,
Attached is a patch to remove some redundant code in the JDBC driver.
* Merges identical code from org.postgresql.jdbc[1|2].Statement into
org.postgresql.Statement.
* Moves escapeSQL() method from Connection to Statement (the only place
it's used)
* Minor cleanup of the new isolation level stuff.
* Minor cleanup of version string handling.
/Anders
_____________________________________________________________________
A n d e r s B e n g t s s o n [EMAIL PROTECTED]
Stockholm, Sweden
Index: src/interfaces/jdbc/org/postgresql/Connection.java
===================================================================
RCS file:
/home/projects/pgsql/cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/Connection.java,v
retrieving revision 1.24
diff -c -r1.24 Connection.java
*** src/interfaces/jdbc/org/postgresql/Connection.java 2001/08/07 17:45:29 1.24
--- src/interfaces/jdbc/org/postgresql/Connection.java 2001/08/08 19:51:53
***************
*** 37,43 ****
*/
private Encoding encoding = Encoding.defaultEncoding();
- private String dbVersionLong;
private String dbVersionNumber;
public boolean CONNECTION_OK = true;
--- 37,42 ----
***************
*** 257,264 ****
firstWarning = null;
- String dbEncoding;
-
// "pg_encoding_to_char(1)" will return 'EUC_JP' for a backend compiled with
multibyte,
// otherwise it's hardcoded to 'SQL_ASCII'.
// If the backend doesn't know about multibyte we can't assume anything about
the encoding
--- 256,261 ----
***************
*** 276,283 ****
if (! resultSet.next()) {
throw new PSQLException("postgresql.con.failed", "failed getting backend
encoding");
}
! dbVersionLong = resultSet.getString(1);
! dbEncoding = resultSet.getString(2);
encoding = Encoding.getEncoding(dbEncoding, info.getProperty("charSet"));
// Initialise object handling
--- 273,282 ----
if (! resultSet.next()) {
throw new PSQLException("postgresql.con.failed", "failed getting backend
encoding");
}
! String version = resultSet.getString(1);
! dbVersionNumber = extractVersionNumber(version);
!
! String dbEncoding = resultSet.getString(2);
encoding = Encoding.getEncoding(dbEncoding, info.getProperty("charSet"));
// Initialise object handling
***************
*** 1002,1026 ****
//this can be simplified
isolationLevel = level;
String isolationLevelSQL;
- switch(isolationLevel) {
- case java.sql.Connection.TRANSACTION_READ_COMMITTED:
- if (haveMinimumServerVersion("7.1")) {
- isolationLevelSQL = "SET SESSION CHARACTERISTICS AS TRANSACTION
ISOLATION LEVEL READ COMMITTED";
- } else {
- isolationLevelSQL = getIsolationLevelSQL();
- }
- break;
-
- case java.sql.Connection.TRANSACTION_SERIALIZABLE:
- if (haveMinimumServerVersion("7.1")) {
- isolationLevelSQL = "SET SESSION CHARACTERISTICS AS TRANSACTION
ISOLATION LEVEL SERIALIZABLE";
- } else {
- isolationLevelSQL = getIsolationLevelSQL();
- }
- break;
! default:
! throw new PSQLException("postgresql.con.isolevel",new
Integer(isolationLevel));
}
ExecSQL(isolationLevelSQL);
}
--- 1001,1022 ----
//this can be simplified
isolationLevel = level;
String isolationLevelSQL;
! if (!haveMinimumServerVersion("7.1")) {
! isolationLevelSQL = getIsolationLevelSQL();
! } else {
! isolationLevelSQL = "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION
LEVEL ";
! switch(isolationLevel) {
! case java.sql.Connection.TRANSACTION_READ_COMMITTED:
! isolationLevelSQL += "READ COMMITTED";
! break;
! case java.sql.Connection.TRANSACTION_SERIALIZABLE:
! isolationLevelSQL += "SERIALIZABLE";
! break;
! default:
! throw new PSQLException("postgresql.con.isolevel",
! new Integer(isolationLevel));
! }
}
ExecSQL(isolationLevelSQL);
}
***************
*** 1094,1152 ****
close();
}
! /**
! * This is an attempt to implement SQL Escape clauses
! */
! public String EscapeSQL(String sql) {
! //if (DEBUG) { System.out.println ("parseSQLEscapes called"); }
!
! // If we find a "{d", assume we have a date escape.
! //
! // Since the date escape syntax is very close to the
! // native Postgres date format, we just remove the escape
! // delimiters.
! //
! // This implementation could use some optimization, but it has
! // worked in practice for two years of solid use.
! int index = sql.indexOf("{d");
! while (index != -1) {
! //System.out.println ("escape found at index: " + index);
! StringBuffer buf = new StringBuffer(sql);
! buf.setCharAt(index, ' ');
! buf.setCharAt(index + 1, ' ');
! buf.setCharAt(sql.indexOf('}', index), ' ');
! sql = new String(buf);
! index = sql.indexOf("{d");
! }
! //System.out.println ("modified SQL: " + sql);
! return sql;
! }
!
! /**
! * What is the version of the server
! *
! * @return the database version
! * @exception SQLException if a database access error occurs
! */
! public String getDBVersionNumber() throws SQLException
{
! if(dbVersionNumber == null) {
! StringTokenizer versionParts = new StringTokenizer(dbVersionLong);
versionParts.nextToken(); /* "PostgreSQL" */
! dbVersionNumber = versionParts.nextToken(); /* "X.Y.Z" */
! }
! return dbVersionNumber;
}
public boolean haveMinimumServerVersion(String ver) throws SQLException
{
! if (getDBVersionNumber().compareTo(ver)>=0)
! return true;
! else
! return false;
}
-
-
-
}
--- 1090,1112 ----
close();
}
! private static String extractVersionNumber(String fullVersionString)
{
! StringTokenizer versionParts = new StringTokenizer(fullVersionString);
versionParts.nextToken(); /* "PostgreSQL" */
! return versionParts.nextToken(); /* "X.Y.Z" */
}
+ /**
+ * Get server version number
+ */
+ public String getDBVersionNumber() {
+ return dbVersionNumber;
+ }
+
public boolean haveMinimumServerVersion(String ver) throws SQLException
{
! return (getDBVersionNumber().compareTo(ver) >= 0);
}
}
Index: src/interfaces/jdbc/org/postgresql/Statement.java
===================================================================
RCS file:
/home/projects/pgsql/cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/Statement.java,v
retrieving revision 1.1
diff -c -r1.1 Statement.java
*** src/interfaces/jdbc/org/postgresql/Statement.java 2001/01/31 09:23:45 1.1
--- src/interfaces/jdbc/org/postgresql/Statement.java 2001/08/08 19:51:53
***************
*** 1,6 ****
package org.postgresql;
! import java.sql.SQLException;
/**
* This class defines methods implemented by the two subclasses
--- 1,7 ----
package org.postgresql;
! import java.sql.*;
! import org.postgresql.util.PSQLException;
/**
* This class defines methods implemented by the two subclasses
***************
*** 24,42 ****
public abstract class Statement {
! public Statement() {
! }
! /**
! * Returns the status message from the current Result.<p>
! * This is used internally by the driver.
! *
! * @return status message from backend
! */
! public abstract String getResultStatusString();
!
! /**
! * @return the OID of the last row inserted
! */
! public abstract int getInsertedOID() throws SQLException;
! }
\ No newline at end of file
--- 25,251 ----
public abstract class Statement {
! /** The warnings chain. */
! protected SQLWarning warnings = null;
! /** The current results */
! protected java.sql.ResultSet result = null;
!
! /** Maximum number of rows to return, 0 = unlimited */
! protected int maxrows = 0;
!
! /** Timeout (in seconds) for a query (not used) */
! protected int timeout = 0;
!
! protected boolean escapeProcessing = true;
!
!
! public Statement() {
! }
!
! /**
! * Returns the status message from the current Result.<p>
! * This is used internally by the driver.
! *
! * @return status message from backend
! */
! public String getResultStatusString() {
! if (result == null)
! return null;
! return ((org.postgresql.ResultSet) result).getStatusString();
! }
!
! /**
! * The maxRows limit is set to limit the number of rows that
! * any ResultSet can contain. If the limit is exceeded, the
! * excess rows are silently dropped.
! *
! * @return the current maximum row limit; zero means unlimited
! * @exception SQLException if a database access error occurs
! */
! public int getMaxRows() throws SQLException {
! return maxrows;
! }
!
! /**
! * Set the maximum number of rows
! *
! * @param max the new max rows limit; zero means unlimited
! * @exception SQLException if a database access error occurs
! * @see getMaxRows
! */
! public void setMaxRows(int max) throws SQLException {
! maxrows = max;
! }
!
! /**
! * If escape scanning is on (the default), the driver will do escape
! * substitution before sending the SQL to the database.
! *
! * @param enable true to enable; false to disable
! * @exception SQLException if a database access error occurs
! */
! public void setEscapeProcessing(boolean enable) throws SQLException {
! escapeProcessing = enable;
! }
!
! /**
! * The queryTimeout limit is the number of seconds the driver
! * will wait for a Statement to execute. If the limit is
! * exceeded, a SQLException is thrown.
! *
! * @return the current query timeout limit in seconds; 0 = unlimited
! * @exception SQLException if a database access error occurs
! */
! public int getQueryTimeout() throws SQLException {
! return timeout;
! }
!
! /**
! * Sets the queryTimeout limit
! *
! * @param seconds - the new query timeout limit in seconds
! * @exception SQLException if a database access error occurs
! */
! public void setQueryTimeout(int seconds) throws SQLException {
! timeout = seconds;
! }
!
! /**
! * The first warning reported by calls on this Statement is
! * returned. A Statement's execute methods clear its SQLWarning
! * chain. Subsequent Statement warnings will be chained to this
! * SQLWarning.
! *
! * <p>The Warning chain is automatically cleared each time a statement
! * is (re)executed.
! *
! * <p><B>Note:</B> If you are processing a ResultSet then any warnings
! * associated with ResultSet reads will be chained on the ResultSet
! * object.
! *
! * @return the first SQLWarning on null
! * @exception SQLException if a database access error occurs
! */
! public SQLWarning getWarnings() throws SQLException {
! return warnings;
! }
!
! /**
! * The maxFieldSize limit (in bytes) is the maximum amount of
! * data returned for any column value; it only applies to
! * BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR and LONGVARCHAR
! * columns. If the limit is exceeded, the excess data is silently
! * discarded.
! *
! * @return the current max column size limit; zero means unlimited
! * @exception SQLException if a database access error occurs
! */
! public int getMaxFieldSize() throws SQLException {
! return 8192; // We cannot change this
! }
!
! /**
! * Sets the maxFieldSize - NOT! - We throw an SQLException just
! * to inform them to stop doing this.
! *
! * @param max the new max column size limit; zero means unlimited
! * @exception SQLException if a database access error occurs
! */
! public void setMaxFieldSize(int max) throws SQLException {
! throw new PSQLException("postgresql.stat.maxfieldsize");
! }
!
! /**
! * After this call, getWarnings returns null until a new warning
! * is reported for this Statement.
! *
! * @exception SQLException if a database access error occurs
! */
! public void clearWarnings() throws SQLException {
! warnings = null;
! }
!
! /**
! * Cancel can be used by one thread to cancel a statement that
! * is being executed by another thread.
! * <p>
! * Not implemented, this method is a no-op.
! *
! * @exception SQLException only because thats the spec.
! */
! public void cancel() throws SQLException {
! // FIXME: Cancel feature has been available since 6.4. Implement it here!
! }
!
! /**
! * New in 7.1: Returns the Last inserted oid. This should be used, rather
! * than the old method using getResultSet, which for executeUpdate returns
! * null.
! * @return OID of last insert
! */
! public int getInsertedOID() throws SQLException {
! if (result == null)
! return 0;
! return ((org.postgresql.ResultSet) result).getInsertedOID();
! }
!
! /**
! * getResultSet returns the current result as a ResultSet. It
! * should only be called once per result.
! *
! * @return the current result set; null if there are no more
! * @exception SQLException if a database access error occurs (why?)
! */
! public java.sql.ResultSet getResultSet() throws SQLException {
! if (result != null && ((org.postgresql.ResultSet) result).reallyResultSet())
! return result;
! return null;
! }
!
! /**
! * In many cases, it is desirable to immediately release a
! * Statement's database and JDBC resources instead of waiting
! * for this to happen when it is automatically closed. The
! * close method provides this immediate release.
! *
! * <p><B>Note:</B> A Statement is automatically closed when it is
! * garbage collected. When a Statement is closed, its current
! * ResultSet, if one exists, is also closed.
! *
! * @exception SQLException if a database access error occurs (why?)
! */
! public void close() throws SQLException {
! // Force the ResultSet to close
! java.sql.ResultSet rs = getResultSet();
! if(rs!=null)
! rs.close();
!
! // Disasociate it from us (For Garbage Collection)
! result = null;
! }
!
! /**
! * This is an attempt to implement SQL Escape clauses
! */
! protected static String escapeSQL(String sql) {
! // If we find a "{d", assume we have a date escape.
! //
! // Since the date escape syntax is very close to the
! // native Postgres date format, we just remove the escape
! // delimiters.
! //
! // This implementation could use some optimization, but it has
! // worked in practice for two years of solid use.
! int index = sql.indexOf("{d");
! while (index != -1) {
! StringBuffer buf = new StringBuffer(sql);
! buf.setCharAt(index, ' ');
! buf.setCharAt(index + 1, ' ');
! buf.setCharAt(sql.indexOf('}', index), ' ');
! sql = new String(buf);
! index = sql.indexOf("{d");
! }
! return sql;
! }
! }
Index: src/interfaces/jdbc/org/postgresql/jdbc1/Statement.java
===================================================================
RCS file:
/home/projects/pgsql/cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Statement.java,v
retrieving revision 1.9
diff -c -r1.9 Statement.java
*** src/interfaces/jdbc/org/postgresql/jdbc1/Statement.java 2001/05/16 16:20:53
1.9
--- src/interfaces/jdbc/org/postgresql/jdbc1/Statement.java 2001/08/08 19:51:54
***************
*** 24,35 ****
*/
public class Statement extends org.postgresql.Statement implements
java.sql.Statement
{
! Connection connection; // The connection who created us
! java.sql.ResultSet result = null; // The current results
! SQLWarning warnings = null; // The warnings chain.
! int timeout = 0; // The timeout for a query (not used)
! boolean escapeProcessing = true;// escape processing flag
! int maxrows=0;
/**
* Constructor for a Statement. It simply sets the connection
--- 24,30 ----
*/
public class Statement extends org.postgresql.Statement implements
java.sql.Statement
{
! private Connection connection; // The connection who created us
/**
* Constructor for a Statement. It simply sets the connection
***************
*** 77,242 ****
}
/**
- * In many cases, it is desirable to immediately release a
- * Statement's database and JDBC resources instead of waiting
- * for this to happen when it is automatically closed. The
- * close method provides this immediate release.
- *
- * <p><B>Note:</B> A Statement is automatically closed when it is
- * garbage collected. When a Statement is closed, its current
- * ResultSet, if one exists, is also closed.
- *
- * @exception SQLException if a database access error occurs (why?)
- */
- public void close() throws SQLException
- {
- // Force the ResultSet to close
- java.sql.ResultSet rs = getResultSet();
- if(rs!=null)
- rs.close();
-
- // Disasociate it from us (For Garbage Collection)
- result = null;
- }
-
- /**
- * The maxFieldSize limit (in bytes) is the maximum amount of
- * data returned for any column value; it only applies to
- * BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR and LONGVARCHAR
- * columns. If the limit is exceeded, the excess data is silently
- * discarded.
- *
- * @return the current max column size limit; zero means unlimited
- * @exception SQLException if a database access error occurs
- */
- public int getMaxFieldSize() throws SQLException
- {
- return 8192; // We cannot change this
- }
-
- /**
- * Sets the maxFieldSize - NOT! - We throw an SQLException just
- * to inform them to stop doing this.
- *
- * @param max the new max column size limit; zero means unlimited
- * @exception SQLException if a database access error occurs
- */
- public void setMaxFieldSize(int max) throws SQLException
- {
- throw new PSQLException("postgresql.stat.maxfieldsize");
- }
-
- /**
- * The maxRows limit is set to limit the number of rows that
- * any ResultSet can contain. If the limit is exceeded, the
- * excess rows are silently dropped.
- *
- * @return the current maximum row limit; zero means unlimited
- * @exception SQLException if a database access error occurs
- */
- public int getMaxRows() throws SQLException
- {
- return maxrows;
- }
-
- /**
- * Set the maximum number of rows
- *
- * @param max the new max rows limit; zero means unlimited
- * @exception SQLException if a database access error occurs
- * @see getMaxRows
- */
- public void setMaxRows(int max) throws SQLException
- {
- maxrows = max;
- }
-
- /**
- * If escape scanning is on (the default), the driver will do escape
- * substitution before sending the SQL to the database.
- *
- * @param enable true to enable; false to disable
- * @exception SQLException if a database access error occurs
- */
- public void setEscapeProcessing(boolean enable) throws SQLException
- {
- escapeProcessing = enable;
- }
-
- /**
- * The queryTimeout limit is the number of seconds the driver
- * will wait for a Statement to execute. If the limit is
- * exceeded, a SQLException is thrown.
- *
- * @return the current query timeout limit in seconds; 0 = unlimited
- * @exception SQLException if a database access error occurs
- */
- public int getQueryTimeout() throws SQLException
- {
- return timeout;
- }
-
- /**
- * Sets the queryTimeout limit
- *
- * @param seconds - the new query timeout limit in seconds
- * @exception SQLException if a database access error occurs
- */
- public void setQueryTimeout(int seconds) throws SQLException
- {
- timeout = seconds;
- }
-
- /**
- * Cancel can be used by one thread to cancel a statement that
- * is being executed by another thread. However, PostgreSQL is
- * a sync. sort of thing, so this really has no meaning - we
- * define it as a no-op (i.e. you can't cancel, but there is no
- * error if you try.)
- *
- * 6.4 introduced a cancel operation, but we have not implemented it
- * yet. Sometime before 6.5, this method will be implemented.
- *
- * @exception SQLException only because thats the spec.
- */
- public void cancel() throws SQLException
- {
- // No-op
- }
-
- /**
- * The first warning reported by calls on this Statement is
- * returned. A Statement's execute methods clear its SQLWarning
- * chain. Subsequent Statement warnings will be chained to this
- * SQLWarning.
- *
- * <p>The Warning chain is automatically cleared each time a statement
- * is (re)executed.
- *
- * <p><B>Note:</B> If you are processing a ResultSet then any warnings
- * associated with ResultSet reads will be chained on the ResultSet
- * object.
- *
- * @return the first SQLWarning on null
- * @exception SQLException if a database access error occurs
- */
- public SQLWarning getWarnings() throws SQLException
- {
- return warnings;
- }
-
- /**
- * After this call, getWarnings returns null until a new warning
- * is reported for this Statement.
- *
- * @exception SQLException if a database access error occurs (why?)
- */
- public void clearWarnings() throws SQLException
- {
- warnings = null;
- }
-
- /**
* 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
--- 72,77 ----
***************
*** 273,299 ****
*/
public boolean execute(String sql) throws SQLException
{
! if(escapeProcessing)
! sql=connection.EscapeSQL(sql);
result = connection.ExecSQL(sql);
return (result != null &&
((org.postgresql.ResultSet)result).reallyResultSet());
}
/**
- * getResultSet returns the current result as a ResultSet. It
- * should only be called once per result.
- *
- * @return the current result set; null if there are no more
- * @exception SQLException if a database access error occurs (why?)
- */
- public java.sql.ResultSet getResultSet() throws SQLException
- {
- if (result != null &&
((org.postgresql.ResultSet)result).reallyResultSet())
- return result;
- return null;
- }
-
- /**
* getUpdateCount returns the current result as an update count,
* if the result is a ResultSet or there are no more results, -1
* is returned. It should only be called once per result.
--- 108,120 ----
*/
public boolean execute(String sql) throws SQLException
{
! if (escapeProcessing)
! sql = escapeSql(sql);
result = connection.ExecSQL(sql);
return (result != null &&
((org.postgresql.ResultSet)result).reallyResultSet());
}
/**
* getUpdateCount returns the current result as an update count,
* if the result is a ResultSet or there are no more results, -1
* is returned. It should only be called once per result.
***************
*** 320,350 ****
result = ((org.postgresql.ResultSet)result).getNext();
return (result != null &&
((org.postgresql.ResultSet)result).reallyResultSet());
}
-
- /**
- * Returns the status message from the current Result.<p>
- * This is used internally by the driver.
- *
- * @return status message from backend
- */
- public String getResultStatusString()
- {
- if(result == null)
- return null;
- return ((org.postgresql.ResultSet)result).getStatusString();
- }
-
- /**
- * New in 7.1: Returns the Last inserted oid. This should be used, rather
- * than the old method using getResultSet, which for executeUpdate returns
- * null.
- * @return OID of last insert
- */
- public int getInsertedOID() throws SQLException
- {
- if(result!=null)
- return ((org.postgresql.ResultSet)result).getInsertedOID();
- return 0;
- }
-
}
--- 141,144 ----
Index: src/interfaces/jdbc/org/postgresql/jdbc2/Statement.java
===================================================================
RCS file:
/home/projects/pgsql/cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc2/Statement.java,v
retrieving revision 1.10
diff -c -r1.10 Statement.java
*** src/interfaces/jdbc/org/postgresql/jdbc2/Statement.java 2001/02/16 16:45:00
1.10
--- src/interfaces/jdbc/org/postgresql/jdbc2/Statement.java 2001/08/08 19:51:55
***************
*** 24,38 ****
*/
public class Statement extends org.postgresql.Statement implements
java.sql.Statement
{
! Connection connection; // The connection who created us
! java.sql.ResultSet result = null; // The current results
! SQLWarning warnings = null; // The warnings chain.
! int timeout = 0; // The timeout for a query (not used)
! boolean escapeProcessing = true;// escape processing flag
private Vector batch=null;
! int resultsettype; // the resultset type to return
! int concurrency; // is it updateable or not?
! int maxrows=0; // the maximum number of rows to return 0=unlimited
/**
* Constructor for a Statement. It simply sets the connection
--- 24,33 ----
*/
public class Statement extends org.postgresql.Statement implements
java.sql.Statement
{
! private Connection connection; // The connection who created us
private Vector batch=null;
! private int resultsettype; // the resultset type to return
! private int concurrency; // is it updateable or not?
/**
* Constructor for a Statement. It simply sets the connection
***************
*** 82,247 ****
}
/**
- * In many cases, it is desirable to immediately release a
- * Statement's database and JDBC resources instead of waiting
- * for this to happen when it is automatically closed. The
- * close method provides this immediate release.
- *
- * <p><B>Note:</B> A Statement is automatically closed when it is
- * garbage collected. When a Statement is closed, its current
- * ResultSet, if one exists, is also closed.
- *
- * @exception SQLException if a database access error occurs (why?)
- */
- public void close() throws SQLException
- {
- // Force the ResultSet to close
- java.sql.ResultSet rs = getResultSet();
- if(rs!=null)
- rs.close();
-
- // Disasociate it from us (For Garbage Collection)
- result = null;
- }
-
- /**
- * The maxFieldSize limit (in bytes) is the maximum amount of
- * data returned for any column value; it only applies to
- * BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR and LONGVARCHAR
- * columns. If the limit is exceeded, the excess data is silently
- * discarded.
- *
- * @return the current max column size limit; zero means unlimited
- * @exception SQLException if a database access error occurs
- */
- public int getMaxFieldSize() throws SQLException
- {
- return 8192; // We cannot change this
- }
-
- /**
- * Sets the maxFieldSize - NOT! - We throw an SQLException just
- * to inform them to stop doing this.
- *
- * @param max the new max column size limit; zero means unlimited
- * @exception SQLException if a database access error occurs
- */
- public void setMaxFieldSize(int max) throws SQLException
- {
- throw new PSQLException("postgresql.stat.maxfieldsize");
- }
-
- /**
- * The maxRows limit is set to limit the number of rows that
- * any ResultSet can contain. If the limit is exceeded, the
- * excess rows are silently dropped.
- *
- * @return the current maximum row limit; zero means unlimited
- * @exception SQLException if a database access error occurs
- */
- public int getMaxRows() throws SQLException
- {
- return maxrows;
- }
-
- /**
- * Set the maximum number of rows
- *
- * @param max the new max rows limit; zero means unlimited
- * @exception SQLException if a database access error occurs
- * @see getMaxRows
- */
- public void setMaxRows(int max) throws SQLException
- {
- maxrows = max;
- }
-
- /**
- * If escape scanning is on (the default), the driver will do escape
- * substitution before sending the SQL to the database.
- *
- * @param enable true to enable; false to disable
- * @exception SQLException if a database access error occurs
- */
- public void setEscapeProcessing(boolean enable) throws SQLException
- {
- escapeProcessing = enable;
- }
-
- /**
- * The queryTimeout limit is the number of seconds the driver
- * will wait for a Statement to execute. If the limit is
- * exceeded, a SQLException is thrown.
- *
- * @return the current query timeout limit in seconds; 0 = unlimited
- * @exception SQLException if a database access error occurs
- */
- public int getQueryTimeout() throws SQLException
- {
- return timeout;
- }
-
- /**
- * Sets the queryTimeout limit
- *
- * @param seconds - the new query timeout limit in seconds
- * @exception SQLException if a database access error occurs
- */
- public void setQueryTimeout(int seconds) throws SQLException
- {
- timeout = seconds;
- }
-
- /**
- * Cancel can be used by one thread to cancel a statement that
- * is being executed by another thread. However, PostgreSQL is
- * a sync. sort of thing, so this really has no meaning - we
- * define it as a no-op (i.e. you can't cancel, but there is no
- * error if you try.)
- *
- * 6.4 introduced a cancel operation, but we have not implemented it
- * yet. Sometime before 6.5, this method will be implemented.
- *
- * @exception SQLException only because thats the spec.
- */
- public void cancel() throws SQLException
- {
- // No-op
- }
-
- /**
- * The first warning reported by calls on this Statement is
- * returned. A Statement's execute methods clear its SQLWarning
- * chain. Subsequent Statement warnings will be chained to this
- * SQLWarning.
- *
- * <p>The Warning chain is automatically cleared each time a statement
- * is (re)executed.
- *
- * <p><B>Note:</B> If you are processing a ResultSet then any warnings
- * associated with ResultSet reads will be chained on the ResultSet
- * object.
- *
- * @return the first SQLWarning on null
- * @exception SQLException if a database access error occurs
- */
- public SQLWarning getWarnings() throws SQLException
- {
- return warnings;
- }
-
- /**
- * After this call, getWarnings returns null until a new warning
- * is reported for this Statement.
- *
- * @exception SQLException if a database access error occurs (why?)
- */
- public void clearWarnings() throws SQLException
- {
- warnings = null;
- }
-
- /**
* 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
--- 77,82 ----
***************
*** 278,285 ****
*/
public boolean execute(String sql) throws SQLException
{
! if(escapeProcessing)
! sql=connection.EscapeSQL(sql);
// 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.
--- 113,120 ----
*/
public boolean execute(String sql) throws SQLException
{
! if (escapeProcessing)
! sql = escapeSQL(sql);
// 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.
***************
*** 300,319 ****
}
/**
- * getResultSet returns the current result as a ResultSet. It
- * should only be called once per result.
- *
- * @return the current result set; null if there are no more
- * @exception SQLException if a database access error occurs (why?)
- */
- public java.sql.ResultSet getResultSet() throws SQLException
- {
- if (result != null &&
((org.postgresql.ResultSet)result).reallyResultSet())
- return result;
- return null;
- }
-
- /**
* getUpdateCount returns the current result as an update count,
* if the result is a ResultSet or there are no more results, -1
* is returned. It should only be called once per result.
--- 135,140 ----
***************
*** 341,359 ****
return (result != null &&
((org.postgresql.ResultSet)result).reallyResultSet());
}
- /**
- * Returns the status message from the current Result.<p>
- * This is used internally by the driver.
- *
- * @return status message from backend
- */
- public String getResultStatusString()
- {
- if(result == null)
- return null;
- return ((org.postgresql.ResultSet)result).getStatusString();
- }
-
// ** JDBC 2 Extensions **
public void addBatch(String sql) throws SQLException
--- 162,167 ----
***************
*** 442,459 ****
{
resultsettype=value;
}
-
- /**
- * New in 7.1: Returns the Last inserted oid. This should be used, rather
- * than the old method using getResultSet, which for executeUpdate returns
- * null.
- * @return OID of last insert
- */
- public int getInsertedOID() throws SQLException
- {
- if(result!=null)
- return ((org.postgresql.ResultSet)result).getInsertedOID();
- return 0;
- }
-
}
--- 250,253 ----
---------------------------(end of broadcast)---------------------------
TIP 3: if posting/reading through Usenet, please send an appropriate
subscribe-nomail command to [EMAIL PROTECTED] so that your
message can get through to the mailing list cleanly
