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.
*/
private Encoding encoding = Encoding.defaultEncoding();
- private String dbVersionLong;
private String dbVersionNumber;
public boolean CONNECTION_OK = true;
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
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
//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);
}
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);
}
-
-
-
}
package org.postgresql;
-import java.sql.SQLException;
+import java.sql.*;
+import org.postgresql.util.PSQLException;
/**
* This class defines methods implemented by the two subclasses
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
+ /** 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;
+ }
+}
*/
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
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
*/
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
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;
- }
-
}
*/
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
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
*/
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.
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
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
{
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;
- }
-
}
projects / postgresql / commitdiff