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 Bengtsson
This commit is contained in:
Bruce Momjian
parent
13923be7c8
commit
454f44e8e3
4 changed files with 263 additions and 506 deletions
|
|
@ -11,7 +11,7 @@ import org.postgresql.util.*;
|
|||
import org.postgresql.core.Encoding;
|
||||
|
||||
/**
|
||||
* $Id: Connection.java,v 1.24 2001/08/07 17:45:29 momjian Exp $
|
||||
* $Id: Connection.java,v 1.25 2001/08/10 14:42:07 momjian Exp $
|
||||
*
|
||||
* This abstract class is used by org.postgresql.Driver to open either the JDBC1 or
|
||||
* JDBC2 versions of the Connection class.
|
||||
|
|
@ -37,7 +37,6 @@ public abstract class Connection
|
|||
*/
|
||||
private Encoding encoding = Encoding.defaultEncoding();
|
||||
|
||||
private String dbVersionLong;
|
||||
private String dbVersionNumber;
|
||||
|
||||
public boolean CONNECTION_OK = true;
|
||||
|
|
@ -257,8 +256,6 @@ public abstract class Connection
|
|||
|
||||
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
|
||||
|
|
@ -276,8 +273,10 @@ public abstract class Connection
|
|||
if (! resultSet.next()) {
|
||||
throw new PSQLException("postgresql.con.failed", "failed getting backend encoding");
|
||||
}
|
||||
dbVersionLong = resultSet.getString(1);
|
||||
dbEncoding = resultSet.getString(2);
|
||||
String version = resultSet.getString(1);
|
||||
dbVersionNumber = extractVersionNumber(version);
|
||||
|
||||
String dbEncoding = resultSet.getString(2);
|
||||
encoding = Encoding.getEncoding(dbEncoding, info.getProperty("charSet"));
|
||||
|
||||
// Initialise object handling
|
||||
|
|
@ -1002,25 +1001,22 @@ public abstract class Connection
|
|||
//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));
|
||||
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,59 +1090,23 @@ public abstract class Connection
|
|||
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
|
||||
private static String extractVersionNumber(String fullVersionString)
|
||||
{
|
||||
if(dbVersionNumber == null) {
|
||||
StringTokenizer versionParts = new StringTokenizer(dbVersionLong);
|
||||
StringTokenizer versionParts = new StringTokenizer(fullVersionString);
|
||||
versionParts.nextToken(); /* "PostgreSQL" */
|
||||
dbVersionNumber = versionParts.nextToken(); /* "X.Y.Z" */
|
||||
}
|
||||
return dbVersionNumber;
|
||||
return versionParts.nextToken(); /* "X.Y.Z" */
|
||||
}
|
||||
|
||||
/**
|
||||
* Get server version number
|
||||
*/
|
||||
public String getDBVersionNumber() {
|
||||
return dbVersionNumber;
|
||||
}
|
||||
|
||||
public boolean haveMinimumServerVersion(String ver) throws SQLException
|
||||
{
|
||||
if (getDBVersionNumber().compareTo(ver)>=0)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
return (getDBVersionNumber().compareTo(ver) >= 0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
package org.postgresql;
|
||||
|
||||
import java.sql.SQLException;
|
||||
import java.sql.*;
|
||||
import org.postgresql.util.PSQLException;
|
||||
|
||||
/**
|
||||
* This class defines methods implemented by the two subclasses
|
||||
|
|
@ -24,19 +25,227 @@ import java.sql.SQLException;
|
|||
|
||||
public abstract class Statement {
|
||||
|
||||
public Statement() {
|
||||
}
|
||||
/** The warnings chain. */
|
||||
protected SQLWarning warnings = null;
|
||||
|
||||
/**
|
||||
* 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();
|
||||
/** The current results */
|
||||
protected java.sql.ResultSet result = null;
|
||||
|
||||
/**
|
||||
* @return the OID of the last row inserted
|
||||
*/
|
||||
public abstract int getInsertedOID() throws SQLException;
|
||||
}
|
||||
/** 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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,12 +24,7 @@ import org.postgresql.util.PSQLException;
|
|||
*/
|
||||
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;
|
||||
private Connection connection; // The connection who created us
|
||||
|
||||
/**
|
||||
* Constructor for a Statement. It simply sets the connection
|
||||
|
|
@ -76,166 +71,6 @@ public class Statement extends org.postgresql.Statement implements java.sql.Stat
|
|||
return this.getUpdateCount();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
|
|
@ -273,26 +108,12 @@ public class Statement extends org.postgresql.Statement implements java.sql.Stat
|
|||
*/
|
||||
public boolean execute(String sql) throws SQLException
|
||||
{
|
||||
if(escapeProcessing)
|
||||
sql=connection.EscapeSQL(sql);
|
||||
if (escapeProcessing)
|
||||
sql = 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
|
||||
|
|
@ -320,31 +141,4 @@ public class Statement extends org.postgresql.Statement implements java.sql.Stat
|
|||
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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,15 +24,10 @@ import org.postgresql.util.*;
|
|||
*/
|
||||
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 Connection connection; // The connection who created us
|
||||
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
|
||||
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
|
||||
|
|
@ -81,166 +76,6 @@ public class Statement extends org.postgresql.Statement implements java.sql.Stat
|
|||
return this.getUpdateCount();
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
|
|
@ -278,8 +113,8 @@ public class Statement extends org.postgresql.Statement implements java.sql.Stat
|
|||
*/
|
||||
public boolean execute(String sql) throws SQLException
|
||||
{
|
||||
if(escapeProcessing)
|
||||
sql=connection.EscapeSQL(sql);
|
||||
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.
|
||||
|
|
@ -299,20 +134,6 @@ public class Statement extends org.postgresql.Statement implements java.sql.Stat
|
|||
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
|
||||
|
|
@ -341,19 +162,6 @@ public class Statement extends org.postgresql.Statement implements java.sql.Stat
|
|||
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
|
||||
|
|
@ -442,18 +250,4 @@ public class Statement extends org.postgresql.Statement implements java.sql.Stat
|
|||
{
|
||||
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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue