database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-17 06:41:09 +03:00
Code Activity

Attached is a patch to remove some redundant code in the JDBC driver.

Browse Source 
* 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
2001-08-10 14:42:07 +00:00
parent 13923be7c8
commit 454f44e8e3
4 changed files with 263 additions and 506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
src/interfaces/jdbc/org/postgresql/jdbc2/Statement.java
View File

@ -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;
}
}