import org.postgresql.util.*;
import org.postgresql.core.*;
-/**
- * $Id: Connection.java,v 1.35 2001/11/12 19:11:56 barry Exp $
+/*
+ * $Id: Connection.java,v 1.36 2001/11/19 22:33:37 momjian Exp $
*
* This abstract class is used by org.postgresql.Driver to open either the JDBC1 or
* JDBC2 versions of the Connection class.
private boolean PG_STATUS;
private String compatible;
- /**
+ /*
* The encoding to use for this connection.
*/
private Encoding encoding = Encoding.defaultEncoding();
private static final int AUTH_REQ_KRB5 = 2;
private static final int AUTH_REQ_PASSWORD = 3;
private static final int AUTH_REQ_CRYPT = 4;
- private static final int AUTH_REQ_MD5 = 5;
+ private static final int AUTH_REQ_MD5 = 5;
// New for 6.3, salt value for crypt authorisation
private String salt;
// Now handle notices as warnings, so things like "show" now work
public SQLWarning firstWarning = null;
- /**
+ /*
* Cache of the current isolation level
*/
private int isolationLevel = java.sql.Connection.TRANSACTION_READ_COMMITTED;
public int pid;
public int ckey;
- /**
+ /*
* This is called by Class.forName() from within org.postgresql.Driver
*/
public Connection()
{}
- /**
+ /*
* This method actually opens the connection. It is called by Driver.
*
* @param host the hostname of the database back end
this_url = url;
PG_DATABASE = database;
PG_USER = info.getProperty("user");
- PG_PASSWORD = info.getProperty("password","");
+ PG_PASSWORD = info.getProperty("password","");
PG_PORT = port;
PG_HOST = host;
PG_STATUS = CONNECTION_BAD;
// are common to all implementations (JDBC1 or 2), they are placed here.
// This should make it easy to maintain the two specifications.
- /**
+ /*
* This adds a warning to the warning chain.
* @param msg message to add
*/
// technique again, we'll know where to place it.
//
// This is generated by the SQL "show datestyle"
- //if(msg.startsWith("NOTICE:") && msg.indexOf("DateStyle")>0) {
+ //if (msg.startsWith("NOTICE:") && msg.indexOf("DateStyle")>0) {
//// 13 is the length off "DateStyle is "
//msg = msg.substring(msg.indexOf("DateStyle is ")+13);
//
//for(int i=0;i<dateStyles.length;i+=2)
- //if(msg.startsWith(dateStyles[i]))
+ //if (msg.startsWith(dateStyles[i]))
//currentDateStyle=i+1; // this is the index of the format
//}
}
- /**
+ /*
* Send a query to the backend. Returns one of the ResultSet
* objects.
*
return ExecSQL(sql, null);
}
- /**
+ /*
* Send a query to the backend. Returns one of the ResultSet
* objects.
*
return new QueryExecutor(sql, stat, pg_stream, this).execute();
}
- /**
+ /*
* In SQL, a result table can be retrieved through a cursor that
* is named. The current row of a result can be updated or deleted
* using a positioned update/delete statement that references the
this.cursor = cursor;
}
- /**
+ /*
* getCursorName gets the cursor name.
*
* @return the current cursor name
return cursor;
}
- /**
+ /*
* We are required to bring back certain information by
* the DatabaseMetaData class. These functions do that.
*
return this_url;
}
- /**
+ /*
* Method getUserName() brings back the User Name (again, we
* saved it)
*
return PG_USER;
}
- /**
+ /*
* Get the character encoding to use for this connection.
*/
public Encoding getEncoding() throws SQLException
return encoding;
}
- /**
+ /*
* This returns the Fastpath API for the current connection.
*
* <p><b>NOTE:</b> This is not part of JDBC, but allows access to
// This holds a reference to the Fastpath API if already open
private Fastpath fastpath = null;
- /**
+ /*
* This returns the LargeObject API for the current connection.
*
* <p><b>NOTE:</b> This is not part of JDBC, but allows access to
// This holds a reference to the LargeObject API if already open
private LargeObjectManager largeobject = null;
- /**
+ /*
* This method is used internally to return an object based around
* org.postgresql's more unique data types.
*
return null;
}
- /**
+ /*
* This stores an object into the database.
* @param o Object to store
* @return OID of the new rectord
}
}
- /**
+ /*
* This allows client code to add a handler for one of org.postgresql's
* more unique data types.
*
// These are required by other common classes
public abstract java.sql.Statement createStatement() throws SQLException;
- /**
+ /*
* This returns a resultset. It must be overridden, so that the correct
* version (from jdbc1 or jdbc2) are returned.
*/
public abstract java.sql.ResultSet getResultSet(org.postgresql.Connection conn, java.sql.Statement stat, Field[] fields, Vector tuples, String status, int updateCount, int insertOID, boolean binaryCursor) throws SQLException;
- /**
+ /*
* In some cases, it is desirable to immediately release a Connection's
* database and JDBC resources instead of waiting for them to be
* automatically released (cant think why off the top of my head)
}
}
- /**
+ /*
* A driver may convert the JDBC sql grammar into its system's
* native SQL grammar prior to sending it; nativeSQL returns the
* native form of the statement that the driver would have sent.
return sql;
}
- /**
+ /*
* The first warning reported by calls on this Connection is
* returned.
*
return firstWarning;
}
- /**
+ /*
* After this call, getWarnings returns null until a new warning
* is reported for this connection.
*
}
- /**
+ /*
* You can put a connection in read-only mode as a hunt to enable
* database optimizations
*
this.readOnly = readOnly;
}
- /**
+ /*
* Tests to see if the connection is in Read Only Mode. Note that
* we cannot really put the database in read only mode, but we pretend
* we can by returning the value of the readOnly flag
return readOnly;
}
- /**
+ /*
* If a connection is in auto-commit mode, than all its SQL
* statements will be executed and committed as individual
* transactions. Otherwise, its SQL statements are grouped
this.autoCommit = autoCommit;
}
- /**
+ /*
* gets the current auto-commit state
*
* @return Current state of the auto-commit mode
return this.autoCommit;
}
- /**
+ /*
* The method commit() makes all changes made since the previous
* commit/rollback permanent and releases any database locks currently
* held by the Connection. This method should only be used when
}
}
- /**
+ /*
* The method rollback() drops all changes made since the previous
* commit/rollback and releases any database locks currently held by
* the Connection.
}
}
- /**
+ /*
* Get this Connection's current transaction isolation mode.
*
* @return the current TRANSACTION_* mode value
return java.sql.Connection.TRANSACTION_READ_COMMITTED;
}
- /**
+ /*
* You can call this method to try to change the transaction
* isolation level using one of the TRANSACTION_* values.
*
ExecSQL(isolationLevelSQL);
}
- /**
+ /*
* Helper method used by setTransactionIsolation(), commit(), rollback()
* and setAutoCommit(). This returns the SQL string needed to
* set the isolation level for a transaction. In 7.1 and later it
return sb.toString();
}
- /**
+ /*
* A sub-space of this Connection's database may be selected by
* setting a catalog name. If the driver does not support catalogs,
* it will silently ignore this request
//no-op
}
- /**
+ /*
* Return the connections current catalog name, or null if no
* catalog name is set, or we dont support catalogs.
*
return PG_DATABASE;
}
- /**
+ /*
* Overides finalize(). If called, it closes the connection.
*
* This was done at the request of Rachel Greenham
return versionParts.nextToken(); /* "X.Y.Z" */
}
- /**
+ /*
* Get server version number
*/
public String getDBVersionNumber()
return (getDBVersionNumber().compareTo(ver) >= 0);
}
- /**
+ /*
* This method returns true if the compatible level set in the connection
* (which can be passed into the connection or specified in the URL)
* is at least the value passed to this method. This is used to toggle
}
- /**
+ /*
* This returns the java.sql.Types type for a PG type oid
*
* @param oid PostgreSQL type oid
return sqlType.intValue();
}
- /**
+ /*
* This returns the java.sql.Types type for a PG type
*
* @param pgTypeName PostgreSQL type name
*/
public abstract int getSQLType(String pgTypeName);
- /**
+ /*
* This returns the oid for a given PG data type
* @param typeName PostgreSQL type name
* @return PostgreSQL oid value for a field of this type
return oid;
}
- /**
+ /*
* We also need to get the PG type name as returned by the back end.
*
* @return the String representation of the type of this field
import org.postgresql.util.PSQLException;
-/**
+/*
* The Java SQL framework allows for multiple database drivers. Each
* driver should supply a class that implements the Driver interface
*
* bringing in vast quantities of supporting code.
*
* <p>When a Driver class is loaded, it should create an instance of itself
- * and register it with the DriverManager. This means that a user can load
+ * and register it with the DriverManager. This means that a user can load
* and register a driver by doing Class.forName("foo.bah.Driver")
*
* @see org.postgresql.Connection
public class Driver implements java.sql.Driver
{
- protected static final int DEBUG=0;
- protected static final int INFO = 1;
- protected static final int WARN = 2;
- protected static final int ERROR = 3;
- protected static final int FATAL = 4;
-
- private static int logLevel= FATAL;
-
- static
- {
- try {
- // moved the registerDriver from the constructor to here
- // because some clients call the driver themselves (I know, as
- // my early jdbc work did - and that was based on other examples).
- // Placing it here, means that the driver is registered once only.
- java.sql.DriverManager.registerDriver(new Driver());
-
- } catch (SQLException e) {
- e.printStackTrace();
- }
- }
-
- /**
- * Construct a new driver and register it with DriverManager
- *
- * @exception SQLException for who knows what!
- */
- public Driver() throws SQLException
- {
- // Set the connectClass variable so that future calls will handle the correct
- // base class
- //if(System.getProperty("java.version").startsWith("1.1")) {
- //connectClass = "postgresql.jdbc1.Connection";
- //} else {
- //connectClass = "postgresql.jdbc2.Connection";
- //}
-
- // Ok, when the above code was introduced in 6.5 it's intention was to allow
- // the driver to automatically detect which version of JDBC was being used
- // and to detect the version of the JVM accordingly.
- //
- // It did this by using the java.version parameter.
- //
- // However, it was quickly discovered that not all JVM's returned an easily
- // parseable version number (ie "1.2") and some don't return a value at all.
- // The latter came from a discussion on the advanced java list.
- //
- // So, to solve this, I've moved the decision out of the driver, and it's now
- // a compile time parameter.
- //
- // For this to work, the Makefile creates a pseudo class which contains the class
- // name that will actually make the connection.
- }
-
- /**
- * Try to make a database connection to the given URL. The driver
- * should return "null" if it realizes it is the wrong kind of
- * driver to connect to the given URL. This will be common, as
- * when the JDBC driverManager is asked to connect to a given URL,
- * it passes the URL to each loaded driver in turn.
- *
- * <p>The driver should raise an SQLException if it is the right driver
- * to connect to the given URL, but has trouble connecting to the
- * database.
- *
- * <p>The java.util.Properties argument can be used to pass arbitrary
- * string tag/value pairs as connection arguments.
- *
- * user - (optional) The user to connect as
- * password - (optional) The password for the user
- * charSet - (optional) The character set to be used for converting
- * to/from the database to unicode. If multibyte is enabled on the
- * server then the character set of the database is used as the default,
- * otherwise the jvm character encoding is used as the default.
- * compatible - This is used to toggle
- * between different functionality as it changes across different releases
- * of the jdbc driver code. The values here are versions of the jdbc
- * client and not server versions. For example in 7.1 get/setBytes
- * worked on LargeObject values, in 7.2 these methods were changed
- * to work on bytea values. This change in functionality could
- * be disabled by setting the compatible level to be "7.1", in
- * which case the driver will revert to the 7.1 functionality.
- *
- * <p>Normally, at least
- * "user" and "password" properties should be included in the
- * properties. For a list of supported
- * character encoding , see
- * http://java.sun.com/products/jdk/1.2/docs/guide/internat/encoding.doc.html
- * Note that you will probably want to have set up the Postgres database
- * itself to use the same encoding, with the "-E <encoding>" argument
- * to createdb.
- *
- * Our protocol takes the forms:
- * <PRE>
- * jdbc:org.postgresql://host:port/database?param1=val1&...
- * </PRE>
- *
- * @param url the URL of the database to connect to
- * @param info a list of arbitrary tag/value pairs as connection
- * arguments
- * @return a connection to the URL or null if it isnt us
- * @exception SQLException if a database access error occurs
- * @see java.sql.Driver#connect
- */
- public java.sql.Connection connect(String url, Properties info) throws SQLException
- {
- if((props = parseURL(url,info))==null)
- {
- Driver.debug("Error in url" + url);
- return null;
- }
- try {
- Driver.debug("connect " + url);
-
- org.postgresql.Connection con = (org.postgresql.Connection)(Class.forName("@JDBCCONNECTCLASS@").newInstance());
- con.openConnection (host(), port(), props, database(), url, this);
- return (java.sql.Connection)con;
- } catch(ClassNotFoundException ex) {
- Driver.debug("error",ex);
- throw new PSQLException("postgresql.jvm.version",ex);
- } catch(PSQLException ex1) {
- // re-throw the exception, otherwise it will be caught next, and a
- // org.postgresql.unusual error will be returned instead.
- throw ex1;
- } catch(Exception ex2) {
- Driver.debug("error",ex2);
- throw new PSQLException("postgresql.unusual",ex2);
- }
- }
-
- /**
- * Returns true if the driver thinks it can open a connection to the
- * given URL. Typically, drivers will return true if they understand
- * the subprotocol specified in the URL and false if they don't. Our
- * protocols start with jdbc:org.postgresql:
- *
- * @see java.sql.Driver#acceptsURL
- * @param url the URL of the driver
- * @return true if this driver accepts the given URL
- * @exception SQLException if a database-access error occurs
- * (Dont know why it would *shrug*)
- */
- public boolean acceptsURL(String url) throws SQLException
- {
- if(parseURL(url,null)==null)
- return false;
- return true;
- }
-
- /**
- * The getPropertyInfo method is intended to allow a generic GUI
- * tool to discover what properties it should prompt a human for
- * in order to get enough information to connect to a database.
- *
- * <p>Note that depending on the values the human has supplied so
- * far, additional values may become necessary, so it may be necessary
- * to iterate through several calls to getPropertyInfo
- *
- * @param url the Url of the database to connect to
- * @param info a proposed list of tag/value pairs that will be sent on
- * connect open.
- * @return An array of DriverPropertyInfo objects describing
- * possible properties. This array may be an empty array if
- * no properties are required
- * @exception SQLException if a database-access error occurs
- * @see java.sql.Driver#getPropertyInfo
- */
- public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException
- {
- Properties p = parseURL(url,info);
-
- // naughty, but its best for speed. If anyone adds a property here, then
- // this _MUST_ be increased to accomodate them.
- DriverPropertyInfo d,dpi[] = new DriverPropertyInfo[0];
- //int i=0;
-
- //dpi[i++] = d = new DriverPropertyInfo("auth",p.getProperty("auth","default"));
- //d.description = "determines if password authentication is used";
- //d.choices = new String[4];
- //d.choices[0]="default"; // Get value from org.postgresql.auth property, defaults to trust
- //d.choices[1]="trust"; // No password authentication
- //d.choices[2]="password"; // Password authentication
- //d.choices[3]="ident"; // Ident (RFC 1413) protocol
-
- return dpi;
- }
-
- /**
- * Gets the drivers major version number
- *
- * @return the drivers major version number
- */
- public int getMajorVersion()
- {
- return @MAJORVERSION@;
- }
-
- /**
- * Get the drivers minor version number
- *
- * @return the drivers minor version number
- */
- public int getMinorVersion()
- {
- return @MINORVERSION@;
- }
-
- /**
- * Returns the VERSION variable from Makefile.global
- */
- public static String getVersion()
- {
- return "@VERSION@";
- }
-
- /**
- * Report whether the driver is a genuine JDBC compliant driver. A
- * driver may only report "true" here if it passes the JDBC compliance
- * tests, otherwise it is required to return false. JDBC compliance
- * requires full support for the JDBC API and full support for SQL 92
- * Entry Level.
- *
- * <p>For PostgreSQL, this is not yet possible, as we are not SQL92
- * compliant (yet).
- */
- public boolean jdbcCompliant()
- {
- return false;
- }
-
- private Properties props;
-
- static private String[] protocols = { "jdbc","postgresql" };
-
- /**
- * Constructs a new DriverURL, splitting the specified URL into its
- * component parts
- * @param url JDBC URL to parse
- * @param defaults Default properties
- * @return Properties with elements added from the url
- * @exception SQLException
- */
- Properties parseURL(String url,Properties defaults) throws SQLException
- {
- int state = -1;
- Properties urlProps = new Properties(defaults);
- String key = "";
- String value = "";
-
- StringTokenizer st = new StringTokenizer(url, ":/;=&?", true);
- for (int count = 0; (st.hasMoreTokens()); count++) {
- String token = st.nextToken();
-
- // PM June 29 1997
- // Added this, to help me understand how this works.
- // Unless you want each token to be processed, leave this commented out
- // but don't delete it.
- //DriverManager.println("wellFormedURL: state="+state+" count="+count+" token='"+token+"'");
-
- // PM Aug 2 1997 - Modified to allow multiple backends
- if (count <= 3) {
- if ((count % 2) == 1 && token.equals(":"))
- ;
- else if((count % 2) == 0) {
- boolean found=(count==0)?true:false;
- for(int tmp=0;tmp<protocols.length;tmp++) {
- if(token.equals(protocols[tmp])) {
- // PM June 29 1997 Added this property to enable the driver
- // to handle multiple backend protocols.
- if(count == 2 && tmp > 0) {
- urlProps.put("Protocol",token);
- found=true;
- }
- }
- }
-
- if(found == false)
- return null;
- } else return null;
- }
- else if (count > 3) {
- if (count == 4 && token.equals("/")) state = 0;
- else if (count == 4) {
- urlProps.put("PGDBNAME", token);
- state = -2;
+ protected static final int DEBUG = 0;
+ protected static final int INFO = 1;
+ protected static final int WARN = 2;
+ protected static final int ERROR = 3;
+ protected static final int FATAL = 4;
+
+ private static int logLevel = FATAL;
+
+ static
+ {
+ try
+ {
+ // moved the registerDriver from the constructor to here
+ // because some clients call the driver themselves (I know, as
+ // my early jdbc work did - and that was based on other examples).
+ // Placing it here, means that the driver is registered once only.
+ java.sql.DriverManager.registerDriver(new Driver());
+
+ }
+ catch (SQLException e)
+ {
+ e.printStackTrace();
+ }
}
- else if (count == 5 && state == 0 && token.equals("/"))
- state = 1;
- else if (count == 5 && state == 0)
- return null;
- else if (count == 6 && state == 1)
- urlProps.put("PGHOST", token);
- else if (count == 7 && token.equals(":")) state = 2;
- else if (count == 8 && state == 2) {
- try {
- Integer portNumber = Integer.decode(token);
- urlProps.put("PGPORT", portNumber.toString());
- } catch (Exception e) {
- return null;
- }
+
+ /*
+ * Construct a new driver and register it with DriverManager
+ *
+ * @exception SQLException for who knows what!
+ */
+ public Driver() throws SQLException
+ {
+ // Set the connectClass variable so that future calls will handle the correct
+ // base class
+ //if (System.getProperty("java.version").startsWith("1.1")) {
+ //connectClass = "postgresql.jdbc1.Connection";
+ //} else {
+ //connectClass = "postgresql.jdbc2.Connection";
+ //}
+
+ // Ok, when the above code was introduced in 6.5 it's intention was to allow
+ // the driver to automatically detect which version of JDBC was being used
+ // and to detect the version of the JVM accordingly.
+ //
+ // It did this by using the java.version parameter.
+ //
+ // However, it was quickly discovered that not all JVM's returned an easily
+ // parseable version number (ie "1.2") and some don't return a value at all.
+ // The latter came from a discussion on the advanced java list.
+ //
+ // So, to solve this, I've moved the decision out of the driver, and it's now
+ // a compile time parameter.
+ //
+ // For this to work, the Makefile creates a pseudo class which contains the class
+ // name that will actually make the connection.
}
- else if ((count == 7 || count == 9) &&
- (state == 1 || state == 2) && token.equals("/"))
- state = -1;
- else if (state == -1) {
- urlProps.put("PGDBNAME", token);
- state = -2;
+
+ /*
+ * Try to make a database connection to the given URL. The driver
+ * should return "null" if it realizes it is the wrong kind of
+ * driver to connect to the given URL. This will be common, as
+ * when the JDBC driverManager is asked to connect to a given URL,
+ * it passes the URL to each loaded driver in turn.
+ *
+ * <p>The driver should raise an SQLException if it is the right driver
+ * to connect to the given URL, but has trouble connecting to the
+ * database.
+ *
+ * <p>The java.util.Properties argument can be used to pass arbitrary
+ * string tag/value pairs as connection arguments.
+ *
+ * user - (optional) The user to connect as
+ * password - (optional) The password for the user
+ * charSet - (optional) The character set to be used for converting
+ * to/from the database to unicode. If multibyte is enabled on the
+ * server then the character set of the database is used as the default,
+ * otherwise the jvm character encoding is used as the default.
+ * compatible - This is used to toggle
+ * between different functionality as it changes across different releases
+ * of the jdbc driver code. The values here are versions of the jdbc
+ * client and not server versions. For example in 7.1 get/setBytes
+ * worked on LargeObject values, in 7.2 these methods were changed
+ * to work on bytea values. This change in functionality could
+ * be disabled by setting the compatible level to be "7.1", in
+ * which case the driver will revert to the 7.1 functionality.
+ *
+ * <p>Normally, at least
+ * "user" and "password" properties should be included in the
+ * properties. For a list of supported
+ * character encoding , see
+ * http://java.sun.com/products/jdk/1.2/docs/guide/internat/encoding.doc.html
+ * Note that you will probably want to have set up the Postgres database
+ * itself to use the same encoding, with the "-E <encoding>" argument
+ * to createdb.
+ *
+ * Our protocol takes the forms:
+ * <PRE>
+ * jdbc:org.postgresql://host:port/database?param1=val1&...
+ * </PRE>
+ *
+ * @param url the URL of the database to connect to
+ * @param info a list of arbitrary tag/value pairs as connection
+ * arguments
+ * @return a connection to the URL or null if it isnt us
+ * @exception SQLException if a database access error occurs
+ * @see java.sql.Driver#connect
+ */
+ public java.sql.Connection connect(String url, Properties info) throws SQLException
+ {
+ if ((props = parseURL(url, info)) == null)
+ {
+ Driver.debug("Error in url" + url);
+ return null;
+ }
+ try
+ {
+ Driver.debug("connect " + url);
+
+ org.postgresql.Connection con = (org.postgresql.Connection)(Class.forName("@JDBCCONNECTCLASS@").newInstance());
+ con.openConnection (host(), port(), props, database(), url, this);
+ return (java.sql.Connection)con;
+ }
+ catch (ClassNotFoundException ex)
+ {
+ Driver.debug("error", ex);
+ throw new PSQLException("postgresql.jvm.version", ex);
+ }
+ catch (PSQLException ex1)
+ {
+ // re-throw the exception, otherwise it will be caught next, and a
+ // org.postgresql.unusual error will be returned instead.
+ throw ex1;
+ }
+ catch (Exception ex2)
+ {
+ Driver.debug("error", ex2);
+ throw new PSQLException("postgresql.unusual", ex2);
+ }
}
- else if (state <= -2 && (count % 2) == 1) {
- // PM Aug 2 1997 - added tests for ? and &
- if (token.equals(";") || token.equals("?") || token.equals("&") ) state = -3;
- else if (token.equals("=")) state = -5;
+
+ /*
+ * Returns true if the driver thinks it can open a connection to the
+ * given URL. Typically, drivers will return true if they understand
+ * the subprotocol specified in the URL and false if they don't. Our
+ * protocols start with jdbc:org.postgresql:
+ *
+ * @see java.sql.Driver#acceptsURL
+ * @param url the URL of the driver
+ * @return true if this driver accepts the given URL
+ * @exception SQLException if a database-access error occurs
+ * (Dont know why it would *shrug*)
+ */
+ public boolean acceptsURL(String url) throws SQLException
+ {
+ if (parseURL(url, null) == null)
+ return false;
+ return true;
}
- else if (state <= -2 && (count % 2) == 0) {
- if (state == -3) key = token;
- else if (state == -5) {
- value = token;
- //DriverManager.println("put("+key+","+value+")");
- urlProps.put(key, value);
- state = -2;
- }
+
+ /*
+ * The getPropertyInfo method is intended to allow a generic GUI
+ * tool to discover what properties it should prompt a human for
+ * in order to get enough information to connect to a database.
+ *
+ * <p>Note that depending on the values the human has supplied so
+ * far, additional values may become necessary, so it may be necessary
+ * to iterate through several calls to getPropertyInfo
+ *
+ * @param url the Url of the database to connect to
+ * @param info a proposed list of tag/value pairs that will be sent on
+ * connect open.
+ * @return An array of DriverPropertyInfo objects describing
+ * possible properties. This array may be an empty array if
+ * no properties are required
+ * @exception SQLException if a database-access error occurs
+ * @see java.sql.Driver#getPropertyInfo
+ */
+ public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException
+ {
+ Properties p = parseURL(url, info);
+
+ // naughty, but its best for speed. If anyone adds a property here, then
+ // this _MUST_ be increased to accomodate them.
+ DriverPropertyInfo d, dpi[] = new DriverPropertyInfo[0];
+ //int i=0;
+
+ //dpi[i++] = d = new DriverPropertyInfo("auth",p.getProperty("auth","default"));
+ //d.description = "determines if password authentication is used";
+ //d.choices = new String[4];
+ //d.choices[0]="default"; // Get value from org.postgresql.auth property, defaults to trust
+ //d.choices[1]="trust"; // No password authentication
+ //d.choices[2]="password"; // Password authentication
+ //d.choices[3]="ident"; // Ident (RFC 1413) protocol
+
+ return dpi;
+ }
+
+ /*
+ * Gets the drivers major version number
+ *
+ * @return the drivers major version number
+ */
+ public int getMajorVersion()
+ {
+ return @MAJORVERSION@;
+ }
+
+ /*
+ * Get the drivers minor version number
+ *
+ * @return the drivers minor version number
+ */
+ public int getMinorVersion()
+ {
+ return @MINORVERSION@;
+ }
+
+ /*
+ * Returns the VERSION variable from Makefile.global
+ */
+ public static String getVersion()
+ {
+ return "@VERSION@";
+ }
+
+ /*
+ * Report whether the driver is a genuine JDBC compliant driver. A
+ * driver may only report "true" here if it passes the JDBC compliance
+ * tests, otherwise it is required to return false. JDBC compliance
+ * requires full support for the JDBC API and full support for SQL 92
+ * Entry Level.
+ *
+ * <p>For PostgreSQL, this is not yet possible, as we are not SQL92
+ * compliant (yet).
+ */
+ public boolean jdbcCompliant()
+ {
+ return false;
+ }
+
+ private Properties props;
+
+ static private String[] protocols = { "jdbc", "postgresql" };
+
+ /*
+ * Constructs a new DriverURL, splitting the specified URL into its
+ * component parts
+ * @param url JDBC URL to parse
+ * @param defaults Default properties
+ * @return Properties with elements added from the url
+ * @exception SQLException
+ */
+ Properties parseURL(String url, Properties defaults) throws SQLException
+ {
+ int state = -1;
+ Properties urlProps = new Properties(defaults);
+ String key = "";
+ String value = "";
+
+ StringTokenizer st = new StringTokenizer(url, ":/;=&?", true);
+ for (int count = 0; (st.hasMoreTokens()); count++)
+ {
+ String token = st.nextToken();
+
+ // PM June 29 1997
+ // Added this, to help me understand how this works.
+ // Unless you want each token to be processed, leave this commented out
+ // but don't delete it.
+ //DriverManager.println("wellFormedURL: state="+state+" count="+count+" token='"+token+"'");
+
+ // PM Aug 2 1997 - Modified to allow multiple backends
+ if (count <= 3)
+ {
+ if ((count % 2) == 1 && token.equals(":"))
+ ;
+ else if ((count % 2) == 0)
+ {
+ boolean found = (count == 0) ? true : false;
+ for (int tmp = 0;tmp < protocols.length;tmp++)
+ {
+ if (token.equals(protocols[tmp]))
+ {
+ // PM June 29 1997 Added this property to enable the driver
+ // to handle multiple backend protocols.
+ if (count == 2 && tmp > 0)
+ {
+ urlProps.put("Protocol", token);
+ found = true;
+ }
+ }
+ }
+
+ if (found == false)
+ return null;
+ }
+ else
+ return null;
+ }
+ else if (count > 3)
+ {
+ if (count == 4 && token.equals("/"))
+ state = 0;
+ else if (count == 4)
+ {
+ urlProps.put("PGDBNAME", token);
+ state = -2;
+ }
+ else if (count == 5 && state == 0 && token.equals("/"))
+ state = 1;
+ else if (count == 5 && state == 0)
+ return null;
+ else if (count == 6 && state == 1)
+ urlProps.put("PGHOST", token);
+ else if (count == 7 && token.equals(":"))
+ state = 2;
+ else if (count == 8 && state == 2)
+ {
+ try
+ {
+ Integer portNumber = Integer.decode(token);
+ urlProps.put("PGPORT", portNumber.toString());
+ }
+ catch (Exception e)
+ {
+ return null;
+ }
+ }
+ else if ((count == 7 || count == 9) &&
+ (state == 1 || state == 2) && token.equals("/"))
+ state = -1;
+ else if (state == -1)
+ {
+ urlProps.put("PGDBNAME", token);
+ state = -2;
+ }
+ else if (state <= -2 && (count % 2) == 1)
+ {
+ // PM Aug 2 1997 - added tests for ? and &
+ if (token.equals(";") || token.equals("?") || token.equals("&") )
+ state = -3;
+ else if (token.equals("="))
+ state = -5;
+ }
+ else if (state <= -2 && (count % 2) == 0)
+ {
+ if (state == -3)
+ key = token;
+ else if (state == -5)
+ {
+ value = token;
+ //DriverManager.println("put("+key+","+value+")");
+ urlProps.put(key, value);
+ state = -2;
+ }
+ }
+ }
+ }
+
+ // PM June 29 1997
+ // This now outputs the properties only if we are logging
+ // PM Sep 13 1999 Commented out, as it throws a Deprecation warning
+ // when compiled under JDK1.2.
+ //if (DriverManager.getLogStream() != null)
+ // urlProps.list(DriverManager.getLogStream());
+
+ return urlProps;
+
+ }
+
+ /*
+ * @return the hostname portion of the URL
+ */
+ public String host()
+ {
+ return props.getProperty("PGHOST", "localhost");
}
- }
- }
-
- // PM June 29 1997
- // This now outputs the properties only if we are logging
- // PM Sep 13 1999 Commented out, as it throws a Deprecation warning
- // when compiled under JDK1.2.
- //if(DriverManager.getLogStream() != null)
- // urlProps.list(DriverManager.getLogStream());
-
- return urlProps;
-
- }
-
- /**
- * @return the hostname portion of the URL
- */
- public String host()
- {
- return props.getProperty("PGHOST","localhost");
- }
-
- /**
- * @return the port number portion of the URL or -1 if no port was specified
- */
- public int port()
- {
- return Integer.parseInt(props.getProperty("PGPORT","@DEF_PGPORT@"));
- }
-
- /**
- * @return the database name of the URL
- */
- public String database()
- {
- return props.getProperty("PGDBNAME");
- }
-
- /**
- * @return the value of any property specified in the URL or properties
- * passed to connect(), or null if not found.
- */
- public String property(String name)
- {
- return props.getProperty(name);
- }
-
- /**
- * This method was added in v6.5, and simply throws an SQLException
- * for an unimplemented method. I decided to do it this way while
- * implementing the JDBC2 extensions to JDBC, as it should help keep the
- * overall driver size down.
- */
- public static SQLException notImplemented()
- {
- return new PSQLException("postgresql.unimplemented");
- }
- /**
- * logging message at the debug level
- * messages will be printed if the logging level is less or equal to DEBUG
- */
- public static void debug(String msg)
- {
- if (logLevel <= DEBUG){
- DriverManager.println(msg);
- }
- }
- /**
- * logging message at the debug level
- * messages will be printed if the logging level is less or equal to DEBUG
- */
- public static void debug(String msg, Exception ex)
- {
- if (logLevel <= DEBUG){
- DriverManager.println(msg + ex != null?ex.getMessage():"null Exception");
- }
- }
- /**
- * logging message at info level
- * messages will be printed if the logging level is less or equal to INFO
- */
- public static void info(String msg)
- {
- if (logLevel <= INFO){
- DriverManager.println(msg);
- }
- }
- /**
- * logging message at info level
- * messages will be printed if the logging level is less or equal to INFO
- */
- public static void info(String msg, Exception ex)
- {
- if (logLevel <= INFO){
- DriverManager.println(msg + ex != null?ex.getMessage():"null Exception");
- }
- }
- /**
- * logging message at warn level
- * messages will be printed if the logging level is less or equal to WARN
- */
- public static void warn(String msg)
- {
- if (logLevel <= WARN){
- DriverManager.println(msg);
- }
- }
- /**
- * logging message at warn level
- * messages will be printed if the logging level is less or equal to WARN
- */
- public static void warn(String msg, Exception ex)
- {
- if (logLevel <= WARN){
- DriverManager.println(msg + ex != null?ex.getMessage():"null Exception");
- }
- }
- /**
- * logging message at error level
- * messages will be printed if the logging level is less or equal to ERROR
- */
- public static void error(String msg)
- {
- if (logLevel <= ERROR){
- DriverManager.println(msg);
- }
- }
- /**
- * logging message at error level
- * messages will be printed if the logging level is less or equal to ERROR
- */
- public static void error(String msg, Exception ex)
- {
- if (logLevel <= ERROR){
- DriverManager.println(msg + ex != null?ex.getMessage():"null Exception");
- }
- }
- /**
- * logging message at fatal level
- * messages will be printed if the logging level is less or equal to FATAL
- */
- public static void fatal(String msg)
- {
- if (logLevel <= FATAL){
- DriverManager.println(msg);
- }
- }
- /**
- * logging message at fatal level
- * messages will be printed if the logging level is less or equal to FATAL
- */
- public static void fatal(String msg, Exception ex)
- {
- if (logLevel <= FATAL){
- DriverManager.println(msg + ex != null?ex.getMessage():"null Exception");
- }
- }
-}
+ /*
+ * @return the port number portion of the URL or -1 if no port was specified
+ */
+ public int port()
+ {
+ return Integer.parseInt(props.getProperty("PGPORT", "@DEF_PGPORT@"));
+ }
+
+ /*
+ * @return the database name of the URL
+ */
+ public String database()
+ {
+ return props.getProperty("PGDBNAME");
+ }
+
+ /*
+ * @return the value of any property specified in the URL or properties
+ * passed to connect(), or null if not found.
+ */
+ public String property(String name)
+ {
+ return props.getProperty(name);
+ }
+
+ /*
+ * This method was added in v6.5, and simply throws an SQLException
+ * for an unimplemented method. I decided to do it this way while
+ * implementing the JDBC2 extensions to JDBC, as it should help keep the
+ * overall driver size down.
+ */
+ public static SQLException notImplemented()
+ {
+ return new PSQLException("postgresql.unimplemented");
+ }
+ /*
+ * logging message at the debug level
+ * messages will be printed if the logging level is less or equal to DEBUG
+ */
+ public static void debug(String msg)
+ {
+ if (logLevel <= DEBUG)
+ {
+ DriverManager.println(msg);
+ }
+ }
+ /*
+ * logging message at the debug level
+ * messages will be printed if the logging level is less or equal to DEBUG
+ */
+ public static void debug(String msg, Exception ex)
+ {
+ if (logLevel <= DEBUG)
+ {
+ DriverManager.println(msg + ex != null ? ex.getMessage() : "null Exception");
+ }
+ }
+ /*
+ * logging message at info level
+ * messages will be printed if the logging level is less or equal to INFO
+ */
+ public static void info(String msg)
+ {
+ if (logLevel <= INFO)
+ {
+ DriverManager.println(msg);
+ }
+ }
+ /*
+ * logging message at info level
+ * messages will be printed if the logging level is less or equal to INFO
+ */
+ public static void info(String msg, Exception ex)
+ {
+ if (logLevel <= INFO)
+ {
+ DriverManager.println(msg + ex != null ? ex.getMessage() : "null Exception");
+ }
+ }
+ /*
+ * logging message at warn level
+ * messages will be printed if the logging level is less or equal to WARN
+ */
+ public static void warn(String msg)
+ {
+ if (logLevel <= WARN)
+ {
+ DriverManager.println(msg);
+ }
+ }
+ /*
+ * logging message at warn level
+ * messages will be printed if the logging level is less or equal to WARN
+ */
+ public static void warn(String msg, Exception ex)
+ {
+ if (logLevel <= WARN)
+ {
+ DriverManager.println(msg + ex != null ? ex.getMessage() : "null Exception");
+ }
+ }
+ /*
+ * logging message at error level
+ * messages will be printed if the logging level is less or equal to ERROR
+ */
+ public static void error(String msg)
+ {
+ if (logLevel <= ERROR)
+ {
+ DriverManager.println(msg);
+ }
+ }
+ /*
+ * logging message at error level
+ * messages will be printed if the logging level is less or equal to ERROR
+ */
+ public static void error(String msg, Exception ex)
+ {
+ if (logLevel <= ERROR)
+ {
+ DriverManager.println(msg + ex != null ? ex.getMessage() : "null Exception");
+ }
+ }
+ /*
+ * logging message at fatal level
+ * messages will be printed if the logging level is less or equal to FATAL
+ */
+ public static void fatal(String msg)
+ {
+ if (logLevel <= FATAL)
+ {
+ DriverManager.println(msg);
+ }
+ }
+ /*
+ * logging message at fatal level
+ * messages will be printed if the logging level is less or equal to FATAL
+ */
+ public static void fatal(String msg, Exception ex)
+ {
+ if (logLevel <= FATAL)
+ {
+ DriverManager.println(msg + ex != null ? ex.getMessage() : "null Exception");
+ }
+ }
+}
import org.postgresql.*;
import org.postgresql.util.*;
-/**
+/*
* org.postgresql.Field is a class used to describe fields in a PostgreSQL
* ResultSet
*/
private Connection conn; // Connection Instantation
- /**
+ /*
* Construct a field based on the information fed to it.
*
* @param conn the connection this field came from
this.mod = mod;
}
- /**
+ /*
* Constructor without mod parameter.
*
* @param conn the connection this field came from
this(conn, name, oid, length, 0);
}
- /**
+ /*
* @return the oid of this Field's data type
*/
public int getOID()
return oid;
}
- /**
+ /*
* @return the mod of this Field's data type
*/
public int getMod()
return mod;
}
- /**
+ /*
* @return the name of this Field's data type
*/
public String getName()
return name;
}
- /**
+ /*
* @return the length of this Field's data type
*/
public int getLength()
return length;
}
- /**
+ /*
* We also need to get the PG type name as returned by the back end.
*
* @return the String representation of the PG type of this field
return conn.getPGType(oid);
}
- /**
+ /*
* We also need to get the java.sql.types type.
*
* @return the int representation of the java.sql.types type of this field
import org.postgresql.core.*;
import org.postgresql.util.*;
-/**
- * $Id: PG_Stream.java,v 1.14 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: PG_Stream.java,v 1.15 2001/11/19 22:33:37 momjian Exp $
*
* This class is used by Connection & PGlobj for communicating with the
* backend.
BytePoolDim1 bytePoolDim1 = new BytePoolDim1();
BytePoolDim2 bytePoolDim2 = new BytePoolDim2();
- /**
+ /*
* Constructor: Connect to the PostgreSQL back end and return
* a stream connection.
*
pg_output = new BufferedOutputStream(connection.getOutputStream(), 8192);
}
- /**
+ /*
* Sends a single character to the back end
*
* @param val the character to be sent
pg_output.write((byte)val);
}
- /**
+ /*
* Sends an integer to the back end
*
* @param val the integer to be sent
Send(buf);
}
- /**
+ /*
* Send an array of bytes to the backend
*
* @param buf The array of bytes to be sent
pg_output.write(buf);
}
- /**
+ /*
* Send an exact array of bytes to the backend - if the length
* has not been reached, send nulls until it has.
*
Send(buf, 0, siz);
}
- /**
+ /*
* Send an exact array of bytes to the backend - if the length
* has not been reached, send nulls until it has.
*
}
}
- /**
+ /*
* Receives a single character from the backend
*
* @return the character received
return c;
}
- /**
+ /*
* Receives an integer from the backend
*
* @param siz length of the integer in bytes
return n;
}
- /**
+ /*
* Receives an integer from the backend
*
* @param siz length of the integer in bytes
return n;
}
- /**
+ /*
* Receives a null-terminated string from the backend. If we don't see a
* null, then we assume something has gone wrong.
*
return encoding.decode(rst, 0, s);
}
- /**
+ /*
* Read a tuple from the back end. A tuple is a two dimensional
* array of bytes
*
return answer;
}
- /**
+ /*
* Reads in a given number of bytes from the backend
*
* @param siz number of bytes to read
return answer;
}
- /**
+ /*
* Reads in a given number of bytes from the backend
*
* @param buf buffer to store result
}
}
- /**
+ /*
* This flushes any pending output to the backend. It is used primarily
* by the Fastpath code.
* @exception SQLException if an I/O error occurs
}
}
- /**
+ /*
* Closes the connection
*
* @exception IOException if a IO Error occurs
-/**
+/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided
* that the following conditions are met:
*
* Copyright 1999 (C) Exoffice Technologies Inc. All Rights Reserved.
*
-* $Id: PostgresqlDataSource.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+* $Id: PostgresqlDataSource.java,v 1.4 2001/11/19 22:33:37 momjian Exp $
*/
import org.postgresql.xa.XADataSourceImpl;
//---------
-/**
+/*
* Implements a JDBC 2.0 {@link javax.sql.DataSource} for the
* PostgreSQL driver with JNDI persistance support. XA and pooled
* connection support is also available, but the application must
{
- /**
+ /*
* Holds the timeout for opening a new connection, specified
* in seconds. The default is obtained from the JDBC driver.
*/
private int _loginTimeout;
- /**
+ /*
* Holds the user's account name.
*/
private String _user;
- /**
+ /*
* Holds the database password.
*/
private String _password;
- /**
+ /*
* Holds the name of the particular database on the server.
*/
private String _databaseName;
- /**
+ /*
* Description of this datasource.
*/
private String _description = "PostgreSQL DataSource";
- /**
+ /*
* Holds the database server name. If null, this is
* assumed to be the localhost.
*/
private String _serverName;
- /**
+ /*
* Holds the port number where a server is listening.
* The default value will open a connection with an
* unspecified port.
private int _portNumber = DEFAULT_PORT;
- /**
+ /*
* The default port number. Since we open the connection
* without specifying the port if it's the default one,
* this value can be meaningless.
private static final int DEFAULT_PORT = 0;
- /**
+ /*
* Holds the log writer to which all messages should be
* printed. The default writer is obtained from the driver
* manager, but it can be specified at the datasource level
private transient PrintWriter _logWriter;
- /**
+ /*
* Each datasource maintains it's own driver, in case of
* driver-specific setup (e.g. pools, log writer).
*/
}
- /**
+ /*
* Sets the name of the particular database on the server.
* The standard name for this property is <tt>databaseName</tt>.
*
}
- /**
+ /*
* Returns the name of the particular database on the server.
* The standard name for this property is <tt>databaseName</tt>.
*
}
- /**
+ /*
* Sets the description of this datasource.
* The standard name for this property is <tt>description</tt>.
*
}
- /**
+ /*
* Returns the description of this datasource.
* The standard name for this property is <tt>description</tt>.
*
}
- /**
+ /*
* Sets the database password.
* The standard name for this property is <tt>password</tt>.
*
}
- /**
+ /*
* Returns the database password.
* The standard name for this property is <tt>password</tt>.
*
}
- /**
+ /*
* Sets the port number where a server is listening.
* The standard name for this property is <tt>portNumber</tt>.
*
}
- /**
+ /*
* Returns the port number where a server is listening.
* The standard name for this property is <tt>portNumber</tt>.
*
}
- /**
+ /*
* Sets the database server name.
* The standard name for this property is <tt>serverName</tt>.
}
- /**
+ /*
* Returns the database server name.
* The standard name for this property is <tt>serverName</tt>.
*
}
- /**
+ /*
* Sets the user's account name.
* The standard name for this property is <tt>user</tt>.
*
}
- /**
+ /*
* Returns the user's account name.
* The standard name for this property is <tt>user</tt>.
*
}
- /**
+ /*
* Returns true if this datasource and the other are equal.
* The two datasources are equal if and only if they will produce
* the exact same connections. Connection properties like database
import org.postgresql.largeobject.*;
import org.postgresql.util.*;
-/**
+/*
* This class implements the common internal methods used by both JDBC 1 and
* JDBC 2 specifications.
*/
// next resultSet in the chain.
protected ResultSet next = null;
- /**
+ /*
* Create a new ResultSet - Note that we create ResultSets to
* represent the results of everything.
*
}
- /**
+ /*
* Create a new ResultSet - Note that we create ResultSets to
* represent the results of everything.
*
this(conn, fields, tuples, status, updateCount, 0, false);
}
- /**
+ /*
* We at times need to know if the resultSet we are working
* with is the result of an UPDATE, DELETE or INSERT (in which
* case, we only have a row count), or of a SELECT operation
return (fields != null);
}
- /**
+ /*
* Since ResultSets can be chained, we need some method of
* finding the next one in the chain. The method getNext()
* returns the next one in the chain.
return (java.sql.ResultSet)next;
}
- /**
+ /*
* This following method allows us to add a ResultSet object
* to the end of the current chain.
*
next.append(r);
}
- /**
+ /*
* If we are just a place holder for results, we still need
* to get an updateCount. This method returns it.
*
return updateCount;
}
- /**
+ /*
* We also need to provide a couple of auxiliary functions for
* the implementation of the ResultMetaData functions. In
* particular, we need to know the number of rows and the
return rows.size();
}
- /**
+ /*
* getColumnCount returns the number of columns
*
* @return the number of columns
return fields.length;
}
- /**
+ /*
* Returns the status message from the backend.<p>
* It is used internally by the driver.
*
return status;
}
- /**
+ /*
* returns the OID of a field.<p>
* It is used internally by the driver.
*
return fields[field -1].getOID();
}
- /**
+ /*
* returns the OID of the last inserted row
*/
public int getInsertedOID()
return insertOID;
}
- /**
+ /*
* This is part of the JDBC API, but is required by org.postgresql.Field
*/
public abstract void close() throws SQLException;
public abstract boolean next() throws SQLException;
public abstract String getString(int i) throws SQLException;
- /**
+ /*
* This is used to fix get*() methods on Money fields. It should only be
* used by those methods!
*
import java.sql.*;
import org.postgresql.util.PSQLException;
-/**
+/*
* This class defines methods implemented by the two subclasses
* org.postgresql.jdbc1.Statement and org.postgresql.jdbc2.Statement that are
* unique to PostgreSQL's JDBC driver.
public Statement()
{}
- /**
+ /*
* Returns the status message from the current Result.<p>
* This is used internally by the driver.
*
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 maxrows;
}
- /**
+ /*
* Set the maximum number of rows
*
* @param max the new max rows limit; zero means unlimited
maxrows = max;
}
- /**
+ /*
* If escape scanning is on (the default), the driver will do escape
* substitution before sending the SQL to the database.
*
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 timeout;
}
- /**
+ /*
* Sets the queryTimeout limit
*
* @param seconds - the new query timeout limit in seconds
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
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
return 8192; // We cannot change this
}
- /**
+ /*
* Sets the maxFieldSize - NOT! - We throw an SQLException just
* to inform them to stop doing this.
*
throw new PSQLException("postgresql.stat.maxfieldsize");
}
- /**
+ /*
* After this call, getWarnings returns null until a new warning
* is reported for this Statement.
*
warnings = null;
}
- /**
+ /*
* Cancel can be used by one thread to cancel a statement that
* is being executed by another thread.
* <p>
// 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 ((org.postgresql.ResultSet) result).getInsertedOID();
}
- /**
+ /*
* getResultSet returns the current result as a ResultSet. It
* should only be called once per 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
result = null;
}
- /**
+ /*
* Filter the SQL string of Java SQL Escape clauses.
*
* Currently implemented Escape clauses are those mentioned in 11.3
package org.postgresql.core;
-/**
+/*
* A simple and efficient class to pool one dimensional byte arrays
* of different sizes.
*/
public class BytePoolDim1
{
- /**
+ /*
* The maximum size of the array we manage.
*/
int maxsize = 256;
- /**
+ /*
* The pools not currently in use
*/
ObjectPool notusemap[] = new ObjectPool[maxsize + 1];
- /**
+ /*
* The pools currently in use
*/
ObjectPool inusemap[] = new ObjectPool[maxsize + 1];
- /**
+ /*
*
*/
byte binit[][] = new byte[maxsize + 1][0];
- /**
+ /*
* Construct a new pool
*/
public BytePoolDim1()
}
}
- /**
+ /*
* Allocate a byte[] of a specified size and put it in the pool. If it's
* larger than maxsize then it is not pooled.
* @return the byte[] allocated
return new byte[size];
/*
// Don't pool if >maxsize
- if(size > maxsize){
+ if (size > maxsize){
return new byte[size];
}
// Fetch from the unused pool if available otherwise allocate a new
// now array
- if(!not_usel.isEmpty()) {
+ if (!not_usel.isEmpty()) {
Object o = not_usel.remove();
b = (byte[]) o;
} else
*/
}
- /**
+ /*
* Release an array
* @param b byte[] to release
*/
not_usel.add(b);
}
- /**
+ /*
* Deallocate all
* @deprecated Real bad things happen if this is called!
*/
// For now until the bug can be removed
return new byte[size][0];
/*
- if(size > maxsize){
+ if (size > maxsize){
return new byte[size][0];
}
ObjectPool not_usel = notusemap[size];
byte b[][] = null;
- if(!not_usel.isEmpty()) {
+ if (!not_usel.isEmpty()) {
Object o = not_usel.remove();
b = (byte[][]) o;
} else
not_usel.add(b);
}
- /**
+ /*
* Deallocate the object cache.
* PM 17/01/01: Commented out this code as it blows away any hope of
* multiple queries on the same connection. I'll redesign the allocation
import java.sql.SQLException;
import org.postgresql.util.*;
-/**
+/*
* Converts to and from the character encoding used by the backend.
*
- * $Id: Encoding.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+ * $Id: Encoding.java,v 1.4 2001/11/19 22:33:37 momjian Exp $
*/
public class Encoding
private static final Encoding DEFAULT_ENCODING = new Encoding(null);
- /**
+ /*
* Preferred JVM encodings for backend encodings.
*/
private static final Hashtable encodings = new Hashtable();
this.encoding = encoding;
}
- /**
+ /*
* Get an Encoding for from the given database encoding and
* the encoding passed in by the user.
*/
}
}
- /**
+ /*
* Get an Encoding matching the given database encoding.
*/
private static Encoding encodingForDatabaseEncoding(String databaseEncoding)
return defaultEncoding();
}
- /**
+ /*
* Name of the (JVM) encoding used.
*/
public String name()
return encoding;
}
- /**
+ /*
* Encode a string to an array of bytes.
*/
public byte[] encode(String s) throws SQLException
}
}
- /**
+ /*
* Decode an array of bytes into a string.
*/
public String decode(byte[] encodedString, int offset, int length) throws SQLException
}
}
- /**
+ /*
* Decode an array of bytes into a string.
*/
public String decode(byte[] encodedString) throws SQLException
return decode(encodedString, 0, encodedString.length);
}
- /**
+ /*
* Get a Reader that decodes the given InputStream.
*/
public Reader getDecodingReader(InputStream in) throws SQLException
}
}
- /**
+ /*
* Get an Encoding using the default encoding for the JVM.
*/
public static Encoding defaultEncoding()
return DEFAULT_ENCODING;
}
- /**
+ /*
* Test if an encoding is available in the JVM.
*/
private static boolean isAvailable(String encodingName)
package org.postgresql.core;
-/**
+/*
* This interface defines the methods to access the memory pool classes.
*/
public interface MemoryPool
{
- /**
+ /*
* Allocate an array from the pool
* @return byte[] allocated
*/
public byte[] allocByte(int size);
- /**
+ /*
* Frees an object back to the pool
* @param o Object to release
*/
package org.postgresql.core;
-/**
+/*
* This interface defines methods needed to implement a simple object pool.
* There are two known classes that implement this, one for jdk1.1 and the
* other for jdk1.2+
public interface ObjectPool
{
- /**
+ /*
* Adds an object to the pool
* @param o Object to add
*/
public void add(Object o);
- /**
+ /*
* Removes an object from the pool
* @param o Object to remove
*/
public void remove(Object o);
- /**
+ /*
* Removes the top object from the pool
* @return Object from the top.
*/
public Object remove();
- /**
+ /*
* @return true if the pool is empty
*/
public boolean isEmpty();
- /**
+ /*
* @return the number of objects in the pool
*/
public int size();
- /**
+ /*
* Adds all objects in one pool to this one
* @param pool The pool to take the objects from
*/
public void addAll(ObjectPool pool);
- /**
+ /*
* Clears the pool of all objects
*/
public void clear();
import org.postgresql.*;
import org.postgresql.util.PSQLException;
-/**
+/*
* Executes a query on the backend.
*
* <p>The lifetime of a QueryExecutor object is from sending the query
* until the response has been received from the backend.
*
- * $Id: QueryExecutor.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+ * $Id: QueryExecutor.java,v 1.4 2001/11/19 22:33:37 momjian Exp $
*/
public class QueryExecutor
private int insert_oid = 0;
private int maxRows;
- /**
+ /*
* Execute a query on the backend.
*/
public java.sql.ResultSet execute() throws SQLException
}
}
- /**
+ /*
* Send a query to the backend.
*/
private void sendQuery(String query) throws SQLException
}
}
- /**
+ /*
* Receive a tuple from the backend.
*
* @param isBinary set if the tuple should be treated as binary data
tuples.addElement(tuple);
}
- /**
+ /*
* Receive command status from the backend.
*/
private void receiveCommandStatus() throws SQLException
}
}
- /**
+ /*
* Receive the field descriptions from the back end.
*/
private void receiveFields() throws SQLException
package org.postgresql.core;
-/**
+/*
* A simple and fast object pool implementation that can pool objects
* of any type. This implementation is not thread safe, it is up to the users
* of this class to assure thread safety.
int maxsize = 16;
Object arr[] = new Object[maxsize];
- /**
+ /*
* Adds an object to the pool
* @param o Object to add
*/
arr[cursize++] = o;
}
- /**
+ /*
* Removes the top object from the pool
* @return Object from the top.
*/
return arr[--cursize];
}
- /**
+ /*
* Removes the given object from the pool
* @param o Object to remove
*/
}
}
- /**
+ /*
* @return true if the pool is empty
*/
public boolean isEmpty()
return cursize == 0;
}
- /**
+ /*
* @return the number of objects in the pool
*/
public int size()
return cursize;
}
- /**
+ /*
* Adds all objects in one pool to this one
* @param pool The pool to take the objects from
*/
cursize = totalsize;
}
- /**
+ /*
* Clears the pool of all objects
*/
public void clear()
// Important: There are a lot of debug code commented out. Please do not
// delete these.
-/**
+/*
* This class implements the Fastpath api.
*
* <p>This is a means of executing functions imbeded in the org.postgresql backend
protected org.postgresql.Connection conn; // our connection
protected org.postgresql.PG_Stream stream; // the network stream
- /**
+ /*
* Initialises the fastpath system
*
* <p><b>Important Notice</b>
//DriverManager.println("Fastpath initialised");
}
- /**
+ /*
* Send a function call to the PostgreSQL backend
*
* @param fnid Function id
// as an error.
//int in = stream.ReceiveChar();
//DriverManager.println("ReceiveChar() = "+in+" '"+((char)in)+"'");
- //if(in!='V') {
- //if(in=='E')
+ //if (in!='V') {
+ //if (in=='E')
//throw new SQLException(stream.ReceiveString(conn.getEncoding()));
//throw new SQLException("Fastpath: expected 'V' from backend, got "+((char)in));
//}
}
}
- /**
+ /*
* Send a function call to the PostgreSQL backend by name.
*
* Note: the mapping for the procedure name to function id needs to exist,
return fastpath(getID(name), resulttype, args);
}
- /**
+ /*
* This convenience method assumes that the return value is an Integer
* @param name Function name
* @param args Function arguments
return i.intValue();
}
- /**
+ /*
* This convenience method assumes that the return value is an Integer
* @param name Function name
* @param args Function arguments
return (byte[])fastpath(name, false, args);
}
- /**
+ /*
* This adds a function to our lookup table.
*
* <p>User code should use the addFunctions method, which is based upon a
func.put(name, new Integer(fnid));
}
- /**
+ /*
* This takes a ResultSet containing two columns. Column 1 contains the
* function name, Column 2 the oid.
*
}
}
- /**
+ /*
* This returns the function id associated by its name
*
* <p>If addFunction() or addFunctions() have not been called for this name,
import java.sql.*;
import org.postgresql.util.*;
-/**
+/*
* Each fastpath call requires an array of arguments, the number and type
* dependent on the function being called.
*
*/
public class FastpathArg
{
- /**
+ /*
* Type of argument, true=integer, false=byte[]
*/
public boolean type;
- /**
+ /*
* Integer value if type=true
*/
public int value;
- /**
+ /*
* Byte value if type=false;
*/
public byte[] bytes;
- /**
+ /*
* Constructs an argument that consists of an integer value
* @param value int value to set
*/
this.value = value;
}
- /**
+ /*
* Constructs an argument that consists of an array of bytes
* @param bytes array to store
*/
this.bytes = bytes;
}
- /**
+ /*
* Constructs an argument that consists of part of a byte array
* @param buf source array
* @param off offset within array
System.arraycopy(buf, off, bytes, 0, len);
}
- /**
+ /*
* Constructs an argument that consists of a String.
* @param s String to store
*/
this(s.getBytes());
}
- /**
+ /*
* This sends this argument down the network stream.
*
* <p>The stream sent consists of the length.int4 then the contents.
import java.sql.*;
import org.postgresql.util.*;
-/**
+/*
* This represents the box datatype within org.postgresql.
*/
public class PGbox extends PGobject implements Serializable, Cloneable
{
- /**
+ /*
* These are the two points.
*/
public PGpoint point[] = new PGpoint[2];
- /**
+ /*
* @param x1 first x coordinate
* @param y1 first y coordinate
* @param x2 second x coordinate
this.point[1] = new PGpoint(x2, y2);
}
- /**
+ /*
* @param p1 first point
* @param p2 second point
*/
this.point[1] = p2;
}
- /**
+ /*
* @param s Box definition in PostgreSQL syntax
* @exception SQLException if definition is invalid
*/
setValue(s);
}
- /**
+ /*
* Required constructor
*/
public PGbox()
setType("box");
}
- /**
+ /*
* This method sets the value of this object. It should be overidden,
* but still called by subclasses.
*
point[1] = new PGpoint(t.getToken(1));
}
- /**
+ /*
* @param obj Object to compare with
* @return true if the two boxes are identical
*/
return false;
}
- /**
+ /*
* This must be overidden to allow the object to be cloned
*/
public Object clone()
return new PGbox((PGpoint)point[0].clone(), (PGpoint)point[1].clone());
}
- /**
+ /*
* @return the PGbox in the syntax expected by org.postgresql
*/
public String getValue()
import java.sql.*;
import org.postgresql.util.*;
-/**
+/*
* This represents org.postgresql's circle datatype, consisting of a point and
* a radius
*/
public class PGcircle extends PGobject implements Serializable, Cloneable
{
- /**
+ /*
* This is the centre point
*/
public PGpoint center;
- /**
+ /*
* This is the radius
*/
double radius;
- /**
+ /*
* @param x coordinate of centre
* @param y coordinate of centre
* @param r radius of circle
this(new PGpoint(x, y), r);
}
- /**
+ /*
* @param c PGpoint describing the circle's centre
* @param r radius of circle
*/
this.radius = r;
}
- /**
+ /*
* @param s definition of the circle in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
setValue(s);
}
- /**
+ /*
* This constructor is used by the driver.
*/
public PGcircle()
setType("circle");
}
- /**
+ /*
* @param s definition of the circle in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
}
}
- /**
+ /*
* @param obj Object to compare with
* @return true if the two boxes are identical
*/
return false;
}
- /**
+ /*
* This must be overidden to allow the object to be cloned
*/
public Object clone()
return new PGcircle((PGpoint)center.clone(), radius);
}
- /**
+ /*
* @return the PGcircle in the syntax expected by org.postgresql
*/
public String getValue()
import java.sql.*;
import org.postgresql.util.*;
-/**
+/*
* This implements a line consisting of two points.
*
* Currently line is not yet implemented in the backend, but this class
*/
public class PGline extends PGobject implements Serializable, Cloneable
{
- /**
+ /*
* These are the two points.
*/
public PGpoint point[] = new PGpoint[2];
- /**
+ /*
* @param x1 coordinate for first point
* @param y1 coordinate for first point
* @param x2 coordinate for second point
this(new PGpoint(x1, y1), new PGpoint(x2, y2));
}
- /**
+ /*
* @param p1 first point
* @param p2 second point
*/
this.point[1] = p2;
}
- /**
+ /*
* @param s definition of the circle in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
setValue(s);
}
- /**
+ /*
* reuired by the driver
*/
public PGline()
setType("line");
}
- /**
+ /*
* @param s Definition of the line segment in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
point[1] = new PGpoint(t.getToken(1));
}
- /**
+ /*
* @param obj Object to compare with
* @return true if the two boxes are identical
*/
return false;
}
- /**
+ /*
* This must be overidden to allow the object to be cloned
*/
public Object clone()
return new PGline((PGpoint)point[0].clone(), (PGpoint)point[1].clone());
}
- /**
+ /*
* @return the PGline in the syntax expected by org.postgresql
*/
public String getValue()
import java.sql.*;
import org.postgresql.util.*;
-/**
+/*
* This implements a lseg (line segment) consisting of two points
*/
public class PGlseg extends PGobject implements Serializable, Cloneable
{
- /**
+ /*
* These are the two points.
*/
public PGpoint point[] = new PGpoint[2];
- /**
+ /*
* @param x1 coordinate for first point
* @param y1 coordinate for first point
* @param x2 coordinate for second point
this(new PGpoint(x1, y1), new PGpoint(x2, y2));
}
- /**
+ /*
* @param p1 first point
* @param p2 second point
*/
this.point[1] = p2;
}
- /**
+ /*
* @param s definition of the circle in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
setValue(s);
}
- /**
+ /*
* reuired by the driver
*/
public PGlseg()
setType("lseg");
}
- /**
+ /*
* @param s Definition of the line segment in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
point[1] = new PGpoint(t.getToken(1));
}
- /**
+ /*
* @param obj Object to compare with
* @return true if the two boxes are identical
*/
return false;
}
- /**
+ /*
* This must be overidden to allow the object to be cloned
*/
public Object clone()
return new PGlseg((PGpoint)point[0].clone(), (PGpoint)point[1].clone());
}
- /**
+ /*
* @return the PGlseg in the syntax expected by org.postgresql
*/
public String getValue()
import java.sql.*;
import org.postgresql.util.*;
-/**
+/*
* This implements a path (a multiple segmented line, which may be closed)
*/
public class PGpath extends PGobject implements Serializable, Cloneable
{
- /**
+ /*
* True if the path is open, false if closed
*/
public boolean open;
- /**
+ /*
* The points defining this path
*/
public PGpoint points[];
- /**
+ /*
* @param points the PGpoints that define the path
* @param open True if the path is open, false if closed
*/
this.open = open;
}
- /**
+ /*
* Required by the driver
*/
public PGpath()
setType("path");
}
- /**
+ /*
* @param s definition of the circle in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
setValue(s);
}
- /**
+ /*
* @param s Definition of the path in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
points[p] = new PGpoint(t.getToken(p));
}
- /**
+ /*
* @param obj Object to compare with
* @return true if the two boxes are identical
*/
return false;
}
- /**
+ /*
* This must be overidden to allow the object to be cloned
*/
public Object clone()
return new PGpath(ary, open);
}
- /**
+ /*
* This returns the polygon in the syntax expected by org.postgresql
*/
public String getValue()
import org.postgresql.util.*;
-/**
+/*
* This implements a version of java.awt.Point, except it uses double
* to represent the coordinates.
*
*/
public class PGpoint extends PGobject implements Serializable, Cloneable
{
- /**
+ /*
* The X coordinate of the point
*/
public double x;
- /**
+ /*
* The Y coordinate of the point
*/
public double y;
- /**
+ /*
* @param x coordinate
* @param y coordinate
*/
this.y = y;
}
- /**
+ /*
* This is called mainly from the other geometric types, when a
* point is imbeded within their definition.
*
setValue(value);
}
- /**
+ /*
* Required by the driver
*/
public PGpoint()
setType("point");
}
- /**
+ /*
* @param s Definition of this point in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
}
}
- /**
+ /*
* @param obj Object to compare with
* @return true if the two boxes are identical
*/
return false;
}
- /**
+ /*
* This must be overidden to allow the object to be cloned
*/
public Object clone()
return new PGpoint(x, y);
}
- /**
+ /*
* @return the PGpoint in the syntax expected by org.postgresql
*/
public String getValue()
return "(" + x + "," + y + ")";
}
- /**
+ /*
* Translate the point with the supplied amount.
* @param x integer amount to add on the x axis
* @param y integer amount to add on the y axis
translate((double)x, (double)y);
}
- /**
+ /*
* Translate the point with the supplied amount.
* @param x double amount to add on the x axis
* @param y double amount to add on the y axis
this.y += y;
}
- /**
+ /*
* Moves the point to the supplied coordinates.
* @param x integer coordinate
* @param y integer coordinate
setLocation(x, y);
}
- /**
+ /*
* Moves the point to the supplied coordinates.
* @param x double coordinate
* @param y double coordinate
this.y = y;
}
- /**
+ /*
* Moves the point to the supplied coordinates.
* refer to java.awt.Point for description of this
* @param x integer coordinate
move((double)x, (double)y);
}
- /**
+ /*
* Moves the point to the supplied java.awt.Point
* refer to java.awt.Point for description of this
* @param p Point to move to
import java.sql.*;
import org.postgresql.util.*;
-/**
+/*
* This implements the polygon datatype within PostgreSQL.
*/
public class PGpolygon extends PGobject implements Serializable, Cloneable
{
- /**
+ /*
* The points defining the polygon
*/
public PGpoint points[];
- /**
+ /*
* Creates a polygon using an array of PGpoints
*
* @param points the points defining the polygon
this.points = points;
}
- /**
+ /*
* @param s definition of the circle in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
setValue(s);
}
- /**
+ /*
* Required by the driver
*/
public PGpolygon()
setType("polygon");
}
- /**
+ /*
* @param s Definition of the polygon in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
points[p] = new PGpoint(t.getToken(p));
}
- /**
+ /*
* @param obj Object to compare with
* @return true if the two boxes are identical
*/
return false;
}
- /**
+ /*
* This must be overidden to allow the object to be cloned
*/
public Object clone()
return new PGpolygon(ary);
}
- /**
+ /*
* @return the PGpolygon in the syntax expected by org.postgresql
*/
public String getValue()
import java.sql.*;
import java.math.*;
-/**
+/*
* CallableStatement is used to execute SQL stored procedures.
*
* <p>JDBC provides a stored procedure SQL escape that allows stored
public class CallableStatement extends PreparedStatement implements java.sql.CallableStatement
{
- /**
+ /*
* @exception SQLException on failure
*/
CallableStatement(Connection c, String q) throws SQLException
super(c, q);
}
- /**
+ /*
* Before executing a stored procedure call you must explicitly
* call registerOutParameter to register the java.sql.Type of each
* out parameter.
public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException
{}
- /**
+ /*
* You must also specify the scale for numeric/decimal types:
*
* <p>Note: When reading the value of an out parameter, you must use
//return true;
//}
- /**
+ /*
* An OUT parameter may have the value of SQL NULL; wasNull
* reports whether the last value read has this special value.
*
//return null;
//}
- /**
+ /*
* Get the value of a CHAR, VARCHAR, or LONGVARCHAR parameter as a
* Java String.
*
//return null;
//}
- /**
+ /*
* Get the value of a BIT parameter as a Java boolean.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return false;
}
- /**
+ /*
* Get the value of a TINYINT parameter as a Java byte.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0;
}
- /**
+ /*
* Get the value of a SMALLINT parameter as a Java short.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0;
}
- /**
+ /*
* Get the value of an INTEGER parameter as a Java int.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0;
}
- /**
+ /*
* Get the value of a BIGINT parameter as a Java long.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0;
}
- /**
+ /*
* Get the value of a FLOAT parameter as a Java float.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return (float) 0.0;
}
- /**
+ /*
* Get the value of a DOUBLE parameter as a Java double.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0.0;
}
- /**
+ /*
* Get the value of a NUMERIC parameter as a java.math.BigDecimal
* object.
*
return null;
}
- /**
+ /*
* Get the value of a SQL BINARY or VARBINARY parameter as a Java
* byte[]
*
//return null;
//}
- /**
+ /*
* Get the value of a SQL DATE parameter as a java.sql.Date object
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return null;
}
- /**
+ /*
* Get the value of a SQL TIME parameter as a java.sql.Time object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return null;
}
- /**
+ /*
* Get the value of a SQL TIMESTAMP parameter as a java.sql.Timestamp object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
// getObject returns a Java object for the parameter.
// See the JDBC spec's "Dynamic Programming" chapter for details.
- /**
+ /*
* Get the value of a parameter as a Java object.
*
* <p>This method returns a Java object whose type coresponds to the
import org.postgresql.largeobject.*;
import org.postgresql.util.*;
-/**
- * $Id: Connection.java,v 1.12 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: Connection.java,v 1.13 2001/11/19 22:33:38 momjian Exp $
*
* A Connection represents a session with a specific database. Within the
* context of a Connection, SQL statements are executed and results are
// This is a cache of the DatabaseMetaData instance for this connection
protected DatabaseMetaData metadata;
- /**
+ /*
* SQL statements without parameters are normally executed using
* Statement objects. If the same SQL statement is executed many
* times, it is more efficient to use a PreparedStatement
return new Statement(this);
}
- /**
+ /*
* A SQL statement with or without IN parameters can be pre-compiled
* and stored in a PreparedStatement object. This object can then
* be used to efficiently execute this statement multiple times.
return new PreparedStatement(this, sql);
}
- /**
+ /*
* A SQL stored procedure call statement is handled by creating a
* CallableStatement for it. The CallableStatement provides methods
* for setting up its IN and OUT parameters and methods for executing
// return new CallableStatement(this, sql);
}
- /**
+ /*
* Tests to see if a Connection is closed
*
* @return the status of the connection
return (pg_stream == null);
}
- /**
+ /*
* A connection's database is able to provide information describing
* its tables, its supported SQL grammar, its stored procedures, the
* capabilities of this connection, etc. This information is made
return metadata;
}
- /**
+ /*
* This overides the method in org.postgresql.Connection and returns a
* ResultSet.
*/
return sqlType;
}
- /**
+ /*
* This table holds the org.postgresql names for the types supported.
* Any types that map to Types.OTHER (eg POINT) don't go into this table.
* They default automatically to Types.OTHER
"abstime", "timestamp"
};
- /**
+ /*
* This table holds the JDBC type for each entry above.
*
* Note: This must be in the same order as above
import org.postgresql.Field;
import org.postgresql.util.PSQLException;
-/**
+/*
* This class provides information about the database as a whole.
*
- * $Id: DatabaseMetaData.java,v 1.38 2001/11/09 02:57:25 davec Exp $
+ * $Id: DatabaseMetaData.java,v 1.39 2001/11/19 22:33:38 momjian Exp $
*
* <p>Many of the methods here return lists of information in ResultSets. You
* can use the normal ResultSet methods such as getString and getInt to
this.connection = conn;
}
- /**
+ /*
* Can all the procedures returned by getProcedures be called
* by the current user?
*
return true; // For now...
}
- /**
+ /*
* Can all the tables returned by getTable be SELECTed by
* the current user?
*
return true; // For now...
}
- /**
+ /*
* What is the URL for this database?
*
* @return the url or null if it cannott be generated
return connection.getURL();
}
- /**
+ /*
* What is our user name as known to the database?
*
* @return our database user name
return connection.getUserName();
}
- /**
+ /*
* Is the database in read-only mode?
*
* @return true if so
return connection.isReadOnly();
}
- /**
+ /*
* Are NULL values sorted high?
*
* @return true if so
return connection.haveMinimumServerVersion("7.2");
}
- /**
+ /*
* Are NULL values sorted low?
*
* @return true if so
return false;
}
- /**
+ /*
* Are NULL values sorted at the start regardless of sort order?
*
* @return true if so
return false;
}
- /**
+ /*
* Are NULL values sorted at the end regardless of sort order?
*
* @return true if so
return ! connection.haveMinimumServerVersion("7.2");
}
- /**
+ /*
* What is the name of this database product - we hope that it is
* PostgreSQL, so we return that explicitly.
*
return "PostgreSQL";
}
- /**
+ /*
* What is the version of this database product.
*
* @return the database version
return connection.getDBVersionNumber();
}
- /**
+ /*
* What is the name of this JDBC driver? If we don't know this
* we are doing something wrong!
*
return "PostgreSQL Native Driver";
}
- /**
+ /*
* What is the version string of this JDBC driver? Again, this is
* static.
*
return connection.this_driver.getVersion();
}
- /**
+ /*
* What is this JDBC driver's major version number?
*
* @return the JDBC driver major version
return connection.this_driver.getMajorVersion();
}
- /**
+ /*
* What is this JDBC driver's minor version number?
*
* @return the JDBC driver minor version
return connection.this_driver.getMinorVersion();
}
- /**
+ /*
* Does the database store tables in a local file? No - it
* stores them in a file on the server.
*
return false;
}
- /**
+ /*
* Does the database use a file for each table? Well, not really,
* since it doesnt use local files.
*
return false;
}
- /**
+ /*
* Does the database treat mixed case unquoted SQL identifiers
* as case sensitive and as a result store them in mixed case?
* A JDBC-Compliant driver will always return false.
return false;
}
- /**
+ /*
* Does the database treat mixed case unquoted SQL identifiers as
* case insensitive and store them in upper case?
*
return false;
}
- /**
+ /*
* Does the database treat mixed case unquoted SQL identifiers as
* case insensitive and store them in lower case?
*
return true;
}
- /**
+ /*
* Does the database treat mixed case unquoted SQL identifiers as
* case insensitive and store them in mixed case?
*
return false;
}
- /**
+ /*
* Does the database treat mixed case quoted SQL identifiers as
* case sensitive and as a result store them in mixed case? A
* JDBC compliant driver will always return true.
return true;
}
- /**
+ /*
* Does the database treat mixed case quoted SQL identifiers as
* case insensitive and store them in upper case?
*
return false;
}
- /**
+ /*
* Does the database treat mixed case quoted SQL identifiers as case
* insensitive and store them in lower case?
*
return false;
}
- /**
+ /*
* Does the database treat mixed case quoted SQL identifiers as case
* insensitive and store them in mixed case?
*
return false;
}
- /**
+ /*
* What is the string used to quote SQL identifiers? This returns
* a space if identifier quoting isn't supported. A JDBC Compliant
* driver will always use a double quote character.
return "\"";
}
- /**
+ /*
* Get a comma separated list of all a database's SQL keywords that
* are NOT also SQL92 keywords.
*
return "";
}
- /**
+ /*
* This is the string that can be used to escape '_' and '%' in
* a search string pattern style catalog search parameters
*
return "\\";
}
- /**
+ /*
* Get all the "extra" characters that can be used in unquoted
* identifier names (those beyond a-zA-Z0-9 and _)
*
return "";
}
- /**
+ /*
* Is "ALTER TABLE" with an add column supported?
* Yes for PostgreSQL 6.1
*
return true;
}
- /**
+ /*
* Is "ALTER TABLE" with a drop column supported?
* Peter 10/10/2000 This was set to true, but 7.1devel doesn't support it!
*
return false;
}
- /**
+ /*
* Is column aliasing supported?
*
* <p>If so, the SQL AS clause can be used to provide names for
return true;
}
- /**
+ /*
* Are concatenations between NULL and non-NULL values NULL? A
* JDBC Compliant driver always returns true
*
return false;
}
- /**
+ /*
* Are table correlation names supported? A JDBC Compliant
* driver always returns true.
*
return true;
}
- /**
+ /*
* If table correlation names are supported, are they restricted to
* be different from the names of the tables?
*
return false;
}
- /**
+ /*
* Are expressions in "ORDER BY" lists supported?
*
* <br>e.g. select * from t order by a + b;
return true;
}
- /**
+ /*
* Can an "ORDER BY" clause use columns not in the SELECT?
*
* @return true if so
return connection.haveMinimumServerVersion("6.4");
}
- /**
+ /*
* Is some form of "GROUP BY" clause supported?
* I checked it, and yes it is.
*
return true;
}
- /**
+ /*
* Can a "GROUP BY" clause use columns not in the SELECT?
*
* @return true if so
return connection.haveMinimumServerVersion("6.4");
}
- /**
+ /*
* Can a "GROUP BY" clause add columns not in the SELECT provided
* it specifies all the columns in the SELECT? Does anyone actually
* understand what they mean here?
return supportsGroupByUnrelated();
}
- /**
+ /*
* Is the escape character in "LIKE" clauses supported? A
* JDBC compliant driver always returns true.
*
return connection.haveMinimumServerVersion("7.1");
}
- /**
+ /*
* Are multiple ResultSets from a single execute supported?
* Well, I implemented it, but I dont think this is possible from
* the back ends point of view.
return false;
}
- /**
+ /*
* Can we have multiple transactions open at once (on different
* connections?)
* I guess we can have, since Im relying on it.
return true;
}
- /**
+ /*
* Can columns be defined as non-nullable. A JDBC Compliant driver
* always returns true.
*
return true;
}
- /**
+ /*
* Does this driver support the minimum ODBC SQL grammar. This
* grammar is defined at:
*
return true;
}
- /**
+ /*
* Does this driver support the Core ODBC SQL grammar. We need
* SQL-92 conformance for this.
*
return false;
}
- /**
+ /*
* Does this driver support the Extended (Level 2) ODBC SQL
* grammar. We don't conform to the Core (Level 1), so we can't
* conform to the Extended SQL Grammar.
return false;
}
- /**
+ /*
* Does this driver support the ANSI-92 entry level SQL grammar?
* All JDBC Compliant drivers must return true. We currently
* report false until 'schema' support is added. Then this
return false;
}
- /**
+ /*
* Does this driver support the ANSI-92 intermediate level SQL
* grammar?
*
return false;
}
- /**
+ /*
* Does this driver support the ANSI-92 full SQL grammar?
*
* @return true if so
return false;
}
- /**
+ /*
* Is the SQL Integrity Enhancement Facility supported?
* I haven't seen this mentioned anywhere, so I guess not
*
return false;
}
- /**
+ /*
* Is some form of outer join supported?
*
* @return true if so
return connection.haveMinimumServerVersion("7.1");
}
- /**
+ /*
* Are full nexted outer joins supported?
*
* @return true if so
return connection.haveMinimumServerVersion("7.1");
}
- /**
+ /*
* Is there limited support for outer joins?
*
* @return true if so
return supportsFullOuterJoins();
}
- /**
+ /*
* What is the database vendor's preferred term for "schema"?
* PostgreSQL doesn't have schemas, but when it does, we'll use the
* term "schema".
return "schema";
}
- /**
+ /*
* What is the database vendor's preferred term for "procedure"?
* Traditionally, "function" has been used.
*
return "function";
}
- /**
+ /*
* What is the database vendor's preferred term for "catalog"?
*
* @return the vendor term
return "database";
}
- /**
+ /*
* Does a catalog appear at the start of a qualified table name?
* (Otherwise it appears at the end).
*
throw org.postgresql.Driver.notImplemented();
}
- /**
+ /*
* What is the Catalog separator.
*
* @return the catalog separator string
throw org.postgresql.Driver.notImplemented();
}
- /**
+ /*
* Can a schema name be used in a data manipulation statement? Nope.
*
* @return true if so
return false;
}
- /**
+ /*
* Can a schema name be used in a procedure call statement? Nope.
*
* @return true if so
return false;
}
- /**
+ /*
* Can a schema be used in a table definition statement? Nope.
*
* @return true if so
return false;
}
- /**
+ /*
* Can a schema name be used in an index definition statement?
*
* @return true if so
return false;
}
- /**
+ /*
* Can a schema name be used in a privilege definition statement?
*
* @return true if so
return false;
}
- /**
+ /*
* Can a catalog name be used in a data manipulation statement?
*
* @return true if so
return false;
}
- /**
+ /*
* Can a catalog name be used in a procedure call statement?
*
* @return true if so
return false;
}
- /**
+ /*
* Can a catalog name be used in a table definition statement?
*
* @return true if so
return false;
}
- /**
+ /*
* Can a catalog name be used in an index definition?
*
* @return true if so
return false;
}
- /**
+ /*
* Can a catalog name be used in a privilege definition statement?
*
* @return true if so
return false;
}
- /**
+ /*
* We support cursors for gets only it seems. I dont see a method
* to get a positioned delete.
*
return false; // For now...
}
- /**
+ /*
* Is positioned UPDATE supported?
*
* @return true if so
return false; // For now...
}
- /**
+ /*
* Is SELECT for UPDATE supported?
*
* @return true if so; false otherwise
return connection.haveMinimumServerVersion("6.5");
}
- /**
+ /*
* Are stored procedure calls using the stored procedure escape
* syntax supported?
*
return false;
}
- /**
+ /*
* Are subqueries in comparison expressions supported? A JDBC
* Compliant driver always returns true.
*
return true;
}
- /**
+ /*
* Are subqueries in 'exists' expressions supported? A JDBC
* Compliant driver always returns true.
*
return true;
}
- /**
+ /*
* Are subqueries in 'in' statements supported? A JDBC
* Compliant driver always returns true.
*
return true;
}
- /**
+ /*
* Are subqueries in quantified expressions supported? A JDBC
* Compliant driver always returns true.
*
return true;
}
- /**
+ /*
* Are correlated subqueries supported? A JDBC Compliant driver
* always returns true.
*
return connection.haveMinimumServerVersion("7.1");
}
- /**
+ /*
* Is SQL UNION supported?
*
* @return true if so
return true; // since 6.3
}
- /**
+ /*
* Is SQL UNION ALL supported?
*
* @return true if so
return connection.haveMinimumServerVersion("7.1");
}
- /**
+ /*
* In PostgreSQL, Cursors are only open within transactions.
*
* @return true if so
return false;
}
- /**
+ /*
* Do we support open cursors across multiple transactions?
*
* @return true if so
return false;
}
- /**
+ /*
* Can statements remain open across commits? They may, but
* this driver cannot guarentee that. In further reflection.
* we are talking a Statement object here, so the answer is
return true;
}
- /**
+ /*
* Can statements remain open across rollbacks? They may, but
* this driver cannot guarentee that. In further contemplation,
* we are talking a Statement object here, so the answer is yes,
return true;
}
- /**
+ /*
* How many hex characters can you have in an inline binary literal
*
* @return the max literal length
return 0; // no limit
}
- /**
+ /*
* What is the maximum length for a character literal
* I suppose it is 8190 (8192 - 2 for the quotes)
*
return 0; // no limit
}
- /**
+ /*
* Whats the limit on column name length. The description of
* pg_class would say '32' (length of pg_class.relname) - we
* should probably do a query for this....but....
return 32;
}
- /**
+ /*
* What is the maximum number of columns in a "GROUP BY" clause?
*
* @return the max number of columns
return 0; // no limit
}
- /**
+ /*
* What's the maximum number of columns allowed in an index?
* 6.0 only allowed one column, but 6.1 introduced multi-column
* indices, so, theoretically, its all of them.
return getMaxColumnsInTable();
}
- /**
+ /*
* What's the maximum number of columns in an "ORDER BY clause?
*
* @return the max columns
return 0; // no limit
}
- /**
+ /*
* What is the maximum number of columns in a "SELECT" list?
*
* @return the max columns
return 0; // no limit
}
- /**
+ /*
* What is the maximum number of columns in a table? From the
* CREATE TABLE reference page...
*
return 1600;
}
- /**
+ /*
* How many active connection can we have at a time to this
* database? Well, since it depends on postmaster, which just
* does a listen() followed by an accept() and fork(), its
return 8192;
}
- /**
+ /*
* What is the maximum cursor name length (the same as all
* the other F***** identifiers!)
*
return 32;
}
- /**
+ /*
* Retrieves the maximum number of bytes for an index, including all
* of the parts of the index.
*
return 0;
}
- /**
+ /*
* What is the maximum length of a procedure name?
* (length of pg_proc.proname used) - again, I really
* should do a query here to get it.
return 0;
}
- /**
+ /*
* What is the maximum length of a single row?
*
* @return max row size in bytes
return 8192; // XXX could be altered
}
- /**
+ /*
* Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY
* blobs? We don't handle blobs yet
*
return false;
}
- /**
+ /*
* What is the maximum length of a SQL statement?
*
* @return max length in bytes
return 16384;
}
- /**
+ /*
* How many active statements can we have open at one time to
* this database? Basically, since each Statement downloads
* the results as the query is executed, we can have many. However,
return 1;
}
- /**
+ /*
* What is the maximum length of a table name? This was found
* from pg_class.relname length
*
return 32;
}
- /**
+ /*
* What is the maximum number of tables that can be specified
* in a SELECT?
*
return 0; // no limit
}
- /**
+ /*
* What is the maximum length of a user name? Well, we generally
* use UNIX like user names in PostgreSQL, so I think this would
* be 8. However, showing the schema for pg_user shows a length
}
- /**
+ /*
* What is the database's default transaction isolation level? We
* do not support this, so all transactions are SERIALIZABLE.
*
return Connection.TRANSACTION_READ_COMMITTED;
}
- /**
+ /*
* Are transactions supported? If not, commit and rollback are noops
* and the isolation level is TRANSACTION_NONE. We do support
* transactions.
return true;
}
- /**
+ /*
* Does the database support the given transaction isolation level?
* We only support TRANSACTION_SERIALIZABLE and TRANSACTION_READ_COMMITTED
*
return false;
}
- /**
+ /*
* Are both data definition and data manipulation transactions
* supported?
*
return true;
}
- /**
+ /*
* Are only data manipulation statements withing a transaction
* supported?
*
return false;
}
- /**
+ /*
* Does a data definition statement within a transaction force
* the transaction to commit? I think this means something like:
*
return false;
}
- /**
+ /*
* Is a data definition statement within a transaction ignored?
* It seems to be (from experiment in previous method)
*
return true;
}
- /**
+ /*
* Get a description of stored procedures available in a catalog
*
* <p>Only procedure descriptions matching the schema and procedure
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of a catalog's stored procedure parameters
* and result columns.
*
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of tables available in a catalog.
*
* <p>Only table descriptions matching the catalog, schema, table
"TABLE", "VIEW", "INDEX", "SEQUENCE"
};
- /**
+ /*
* Get the schema names available in this database. The results
* are ordered by schema name.
*
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get the catalog names available in this database. The results
* are ordered by catalog name.
*
return connection.createStatement().executeQuery("select datname as TABLE_CAT from pg_database;");
}
- /**
+ /*
* Get the table types available in this database. The results
* are ordered by table type.
*
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of table columns available in a catalog.
*
* <P>Only column descriptions matching the catalog, schema, table
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of the access rights for a table's columns.
*
* <P>Only privileges matching the column name criteria are
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of the access rights for each table available
* in a catalog.
*
throw org.postgresql.Driver.notImplemented();
}
- /**
+ /*
* Get a description of a table's optimal set of columns that
* uniquely identifies a row. They are ordered by SCOPE.
*
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of a table's columns that are automatically
* updated when any value in a row is updated. They are
* unordered.
throw org.postgresql.Driver.notImplemented();
}
- /**
+ /*
* Get a description of a table's primary key columns. They
* are ordered by COLUMN_NAME.
*
);
}
- private java.sql.ResultSet getImportedExportedKeys(String catalog, String schema, String primaryTable, String foreignTable) throws SQLException
- {
- Field f[]=new Field[14];
-
- f[0]=new Field(connection, "PKTABLE_CAT", iVarcharOid, 32);
- f[1]=new Field(connection, "PKTABLE_SCHEM", iVarcharOid, 32);
- f[2]=new Field(connection, "PKTABLE_NAME", iVarcharOid, 32);
- f[3]=new Field(connection, "PKCOLUMN_NAME", iVarcharOid, 32);
- f[4]=new Field(connection, "FKTABLE_CAT", iVarcharOid, 32);
- f[5]=new Field(connection, "FKTABLE_SCHEM", iVarcharOid, 32);
- f[6]=new Field(connection, "FKTABLE_NAME", iVarcharOid, 32);
- f[7]=new Field(connection, "FKCOLUMN_NAME", iVarcharOid, 32);
- f[8]=new Field(connection, "KEY_SEQ", iInt2Oid, 2);
- f[9]=new Field(connection, "UPDATE_RULE", iInt2Oid, 2);
- f[10]=new Field(connection, "DELETE_RULE", iInt2Oid, 2);
- f[11]=new Field(connection, "FK_NAME", iVarcharOid, 32);
- f[12]=new Field(connection, "PK_NAME", iVarcharOid, 32);
- f[13]=new Field(connection, "DEFERRABILITY", iInt2Oid, 2);
-
- java.sql.ResultSet rs = connection.ExecSQL("SELECT c.relname,c2.relname,"
- + "t.tgconstrname,ic.relname,"
- + "t.tgdeferrable,t.tginitdeferred,"
- + "t.tgnargs,t.tgargs,p.proname "
- + "FROM pg_trigger t,pg_class c,pg_class c2,"
- + "pg_class ic,pg_proc p, pg_index i "
- + "WHERE t.tgrelid=c.oid AND t.tgconstrrelid=c2.oid "
- + "AND t.tgfoid=p.oid AND tgisconstraint "
- + ((primaryTable!=null) ? "AND c2.relname='"+primaryTable+"' " : "")
- + ((foreignTable!=null) ? "AND c.relname='"+foreignTable+"' " : "")
- + "AND i.indrelid=c.oid "
- + "AND i.indexrelid=ic.oid AND i.indisprimary "
- + "ORDER BY c.relname,c2.relname"
- );
- Vector tuples = new Vector();
- short seq=0;
- if(rs.next()) {
+ private java.sql.ResultSet getImportedExportedKeys(String catalog, String schema, String primaryTable, String foreignTable) throws SQLException
+ {
+ Field f[]=new Field[14];
+
+ f[0]=new Field(connection, "PKTABLE_CAT", iVarcharOid, 32);
+ f[1]=new Field(connection, "PKTABLE_SCHEM", iVarcharOid, 32);
+ f[2]=new Field(connection, "PKTABLE_NAME", iVarcharOid, 32);
+ f[3]=new Field(connection, "PKCOLUMN_NAME", iVarcharOid, 32);
+ f[4]=new Field(connection, "FKTABLE_CAT", iVarcharOid, 32);
+ f[5]=new Field(connection, "FKTABLE_SCHEM", iVarcharOid, 32);
+ f[6]=new Field(connection, "FKTABLE_NAME", iVarcharOid, 32);
+ f[7]=new Field(connection, "FKCOLUMN_NAME", iVarcharOid, 32);
+ f[8]=new Field(connection, "KEY_SEQ", iInt2Oid, 2);
+ f[9]=new Field(connection, "UPDATE_RULE", iInt2Oid, 2);
+ f[10]=new Field(connection, "DELETE_RULE", iInt2Oid, 2);
+ f[11]=new Field(connection, "FK_NAME", iVarcharOid, 32);
+ f[12]=new Field(connection, "PK_NAME", iVarcharOid, 32);
+ f[13]=new Field(connection, "DEFERRABILITY", iInt2Oid, 2);
+
+ java.sql.ResultSet rs = connection.ExecSQL("SELECT c.relname,c2.relname,"
+ + "t.tgconstrname,ic.relname,"
+ + "t.tgdeferrable,t.tginitdeferred,"
+ + "t.tgnargs,t.tgargs,p.proname "
+ + "FROM pg_trigger t,pg_class c,pg_class c2,"
+ + "pg_class ic,pg_proc p, pg_index i "
+ + "WHERE t.tgrelid=c.oid AND t.tgconstrrelid=c2.oid "
+ + "AND t.tgfoid=p.oid AND tgisconstraint "
+ + ((primaryTable!=null) ? "AND c2.relname='"+primaryTable+"' " : "")
+ + ((foreignTable!=null) ? "AND c.relname='"+foreignTable+"' " : "")
+ + "AND i.indrelid=c.oid "
+ + "AND i.indexrelid=ic.oid AND i.indisprimary "
+ + "ORDER BY c.relname,c2.relname"
+ );
+ Vector tuples = new Vector();
+ short seq=0;
+ if (rs.next()) {
boolean hasMore;
do {
- byte tuple[][]=new byte[14][0];
- for (int k = 0;k < 14;k++)
+ byte tuple[][]=new byte[14][0];
+ for (int k = 0;k < 14;k++)
tuple[k] = null;
- String fKeyName=rs.getString(3);
- boolean foundRule=false;
- do {
- String proname=rs.getString(9);
- if(proname!=null && proname.startsWith("RI_FKey_")) {
- int col=-1;
- if(proname.endsWith("_upd")) col=9; // UPDATE_RULE
- else if(proname.endsWith("_del")) col=10; // DELETE_RULE
- if(col>-1) {
- String rule=proname.substring(8, proname.length()-4);
- int action=importedKeyNoAction;
- if("cascade".equals(rule)) action=importedKeyCascade;
- else if("setnull".equals(rule)) action=importedKeySetNull;
- else if("setdefault".equals(rule)) action=importedKeySetDefault;
- tuple[col]=Integer.toString(action).getBytes();
- foundRule=true;
- }
- }
- } while((hasMore=rs.next()) && fKeyName.equals(rs.getString(3)));
+ String fKeyName=rs.getString(3);
+ boolean foundRule=false;
+ do {
+ String proname=rs.getString(9);
+ if (proname!=null && proname.startsWith("RI_FKey_")) {
+ int col=-1;
+ if (proname.endsWith("_upd")) col=9; // UPDATE_RULE
+ else if (proname.endsWith("_del")) col=10; // DELETE_RULE
+ if (col>-1) {
+ String rule=proname.substring(8, proname.length()-4);
+ int action=importedKeyNoAction;
+ if ("cascade".equals(rule)) action=importedKeyCascade;
+ else if ("setnull".equals(rule)) action=importedKeySetNull;
+ else if ("setdefault".equals(rule)) action=importedKeySetDefault;
+ tuple[col]=Integer.toString(action).getBytes();
+ foundRule=true;
+ }
+ }
+ } while ((hasMore=rs.next()) && fKeyName.equals(rs.getString(3)));
- if(foundRule) {
+ if (foundRule) {
tuple[2]=rs.getBytes(2); //PKTABLE_NAME
tuple[6]=rs.getBytes(1); //FKTABLE_NAME
String s=rs.getString(8);
int pos=s.lastIndexOf("\\000");
for(int c=0;c<numColumns;c++) {
- if(pos>-1) {
+ if (pos>-1) {
int pos2=s.lastIndexOf("\\000", pos-1);
- if(pos2>-1) {
- if(fkeyColumns.length()>0) fkeyColumns.insert(0, ',');
- fkeyColumns.insert(0, s.substring(pos2+4, pos)); //FKCOLUMN_NAME
- pos=s.lastIndexOf("\\000", pos2-1);
- if(pos>-1) {
- if(pkeyColumns.length()>0) pkeyColumns.insert(0, ',');
+ if (pos2>-1) {
+ if (fkeyColumns.length()>0) fkeyColumns.insert(0, ',');
+ fkeyColumns.insert(0, s.substring(pos2+4, pos)); //FKCOLUMN_NAME
+ pos=s.lastIndexOf("\\000", pos2-1);
+ if (pos>-1) {
+ if (pkeyColumns.length()>0) pkeyColumns.insert(0, ',');
pkeyColumns.insert(0, s.substring(pos+4, pos2)); //PKCOLUMN_NAME
- }
+ }
+ }
}
- }
}
tuple[7]=fkeyColumns.toString().getBytes(); //FKCOLUMN_NAME
tuple[3]=pkeyColumns.toString().getBytes(); //PKCOLUMN_NAME
int deferrability=importedKeyNotDeferrable;
boolean deferrable=rs.getBoolean(5);
boolean initiallyDeferred=rs.getBoolean(6);
- if(deferrable) {
- if(initiallyDeferred)
+ if (deferrable) {
+ if (initiallyDeferred)
deferrability=importedKeyInitiallyDeferred;
else
deferrability=importedKeyInitiallyImmediate;
tuples.addElement(tuple);
}
- } while(hasMore);
+ } while (hasMore);
}
return new ResultSet(connection, f, tuples, "OK", 1);
}
- /**
+ /*
* Get a description of the primary key columns that are
* referenced by a table's foreign key columns (the primary keys
* imported by a table). They are ordered by PKTABLE_CAT,
* @return ResultSet each row is a primary key column description
* @see #getExportedKeys
*/
- public java.sql.ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException
- {
- return getImportedExportedKeys(catalog, schema, null, table);
- }
+ public java.sql.ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException
+ {
+ return getImportedExportedKeys(catalog, schema, null, table);
+ }
- /**
+ /*
* Get a description of a foreign key columns that reference a
* table's primary key columns (the foreign keys exported by a
* table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM,
return getImportedExportedKeys(catalog, schema, table, null);
}
- /**
+ /*
* Get a description of the foreign key columns in the foreign key
* table that reference the primary key columns of the primary key
* table (describe how one table imports another's key.) This
return getImportedExportedKeys(primaryCatalog, primarySchema, primaryTable, foreignTable);
}
- /**
+ /*
* Get a description of all the standard SQL types supported by
* this database. They are ordered by DATA_TYPE and then by how
* closely the data type maps to the corresponding JDBC SQL type.
throw new PSQLException("postgresql.metadata.unavailable");
}
- /**
+ /*
* Get a description of a table's indices and statistics. They are
* ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION.
*
import org.postgresql.largeobject.*;
import org.postgresql.util.*;
-/**
+/*
* A SQL Statement is pre-compiled and stored in a PreparedStatement object.
* This object can then be used to efficiently execute this statement multiple
* times.
String[] inStrings;
Connection connection;
- /**
+ /*
* Constructor for the PreparedStatement class.
* Split the SQL statement into segments - separated by the arguments.
* When we rebuild the thing with the arguments, we can substitute the
templateStrings[i] = (String)v.elementAt(i);
}
- /**
+ /*
* A Prepared SQL query is executed and its ResultSet is returned
*
* @return a ResultSet that contains the data produced by the
return super.executeQuery(s.toString()); // in Statement class
}
- /**
+ /*
* Execute a SQL INSERT, UPDATE or DELETE statement. In addition,
* SQL statements that return nothing such as SQL DDL statements can
* be executed.
return super.executeUpdate(s.toString()); // in Statement class
}
- /**
+ /*
* Set a parameter to SQL NULL
*
* <p><B>Note:</B> You must specify the parameters SQL type (although
set(parameterIndex, "null");
}
- /**
+ /*
* Set a parameter to a Java boolean value. The driver converts this
* to a SQL BIT value when it sends it to the database.
*
set(parameterIndex, x ? "'t'" : "'f'");
}
- /**
+ /*
* Set a parameter to a Java byte value. The driver converts this to
* a SQL TINYINT value when it sends it to the database.
*
set(parameterIndex, Integer.toString(x));
}
- /**
+ /*
* Set a parameter to a Java short value. The driver converts this
* to a SQL SMALLINT value when it sends it to the database.
*
set(parameterIndex, Integer.toString(x));
}
- /**
+ /*
* Set a parameter to a Java int value. The driver converts this to
* a SQL INTEGER value when it sends it to the database.
*
set(parameterIndex, Integer.toString(x));
}
- /**
+ /*
* Set a parameter to a Java long value. The driver converts this to
* a SQL BIGINT value when it sends it to the database.
*
set(parameterIndex, Long.toString(x));
}
- /**
+ /*
* Set a parameter to a Java float value. The driver converts this
* to a SQL FLOAT value when it sends it to the database.
*
set(parameterIndex, Float.toString(x));
}
- /**
+ /*
* Set a parameter to a Java double value. The driver converts this
* to a SQL DOUBLE value when it sends it to the database
*
set(parameterIndex, Double.toString(x));
}
- /**
+ /*
* Set a parameter to a java.lang.BigDecimal value. The driver
* converts this to a SQL NUMERIC value when it sends it to the
* database.
set(parameterIndex, x.toString());
}
- /**
+ /*
* Set a parameter to a Java String value. The driver converts this
* to a SQL VARCHAR or LONGVARCHAR value (depending on the arguments
* size relative to the driver's limits on VARCHARs) when it sends it
}
}
- /**
+ /*
* Set a parameter to a Java array of bytes. The driver converts this
* to a SQL VARBINARY or LONGVARBINARY (depending on the argument's
* size relative to the driver's limits on VARBINARYs) when it sends
}
}
- /**
+ /*
* Set a parameter to a java.sql.Date value. The driver converts this
* to a SQL DATE value when it sends it to the database.
*
//set(parameterIndex, df.format(new java.util.Date(x.getTime()+86400000)));
}
- /**
+ /*
* Set a parameter to a java.sql.Time value. The driver converts
* this to a SQL TIME value when it sends it to the database.
*
}
}
- /**
+ /*
* Set a parameter to a java.sql.Timestamp value. The driver converts
* this to a SQL TIMESTAMP value when it sends it to the database.
*
}
}
- /**
+ /*
* When a very large ASCII value is input to a LONGVARCHAR parameter,
* it may be more practical to send it via a java.io.InputStream.
* JDBC will read the data from the stream as needed, until it reaches
}
}
- /**
+ /*
* When a very large Unicode value is input to a LONGVARCHAR parameter,
* it may be more practical to send it via a java.io.InputStream.
* JDBC will read the data from the stream as needed, until it reaches
}
}
- /**
+ /*
* When a very large binary value is input to a LONGVARBINARY parameter,
* it may be more practical to send it via a java.io.InputStream.
* JDBC will read the data from the stream as needed, until it reaches
}
}
- /**
+ /*
* In general, parameter values remain in force for repeated used of a
* Statement. Setting a parameter value automatically clears its
* previous value. However, in coms cases, it is useful to immediately
inStrings[i] = null;
}
- /**
+ /*
* Set the value of a parameter using an object; use the java.lang
* equivalent objects for integral values.
*
setObject(parameterIndex, x, targetSqlType, 0);
}
- /**
+ /*
* This stores an Object into a parameter.
* <p>New for 6.4, if the object is not recognised, but it is
* Serializable, then the object is serialised using the
setLong(parameterIndex, connection.putObject(x));
}
- /**
+ /*
* Some prepared statements return multiple results; the execute method
* handles these complex statements as well as the simpler form of
* statements handled by executeQuery and executeUpdate
return super.execute(s.toString()); // in Statement class
}
- /**
+ /*
* Returns the SQL statement with the current template values
* substituted.
*/
// END OF PUBLIC INTERFACE
// **************************************************************
- /**
+ /*
* There are a lot of setXXX classes which all basically do
* the same thing. We need a method which actually does the
* set for us.
import org.postgresql.util.*;
import org.postgresql.core.Encoding;
-/**
+/*
* A ResultSet provides access to a table of data generated by executing a
* Statement. The table rows are retrieved in sequence. Within a row its
* column values can be accessed in any order.
*/
public class ResultSet extends org.postgresql.ResultSet implements java.sql.ResultSet
{
- /**
+ /*
* Create a new ResultSet - Note that we create ResultSets to
* represent the results of everything.
*
super(conn, fields, tuples, status, updateCount, insertOID, binaryCursor);
}
- /**
+ /*
* Create a new ResultSet - Note that we create ResultSets to
* represent the results of everything.
*
super(conn, fields, tuples, status, updateCount, 0, false);
}
- /**
+ /*
* A ResultSet is initially positioned before its first row,
* the first call to next makes the first row the current row;
* the second call makes the second row the current row, etc.
return true;
}
- /**
+ /*
* In some cases, it is desirable to immediately release a ResultSet
* database and JDBC resources instead of waiting for this to happen
* when it is automatically closed. The close method provides this
rows.setSize(0);
}
- /**
+ /*
* A column may have the value of SQL NULL; wasNull() reports whether
* the last column read had this special value. Note that you must
* first call getXXX on a column to try to read its value and then
return wasNullFlag;
}
- /**
+ /*
* Get the value of a column in the current row as a Java String
*
* @param columnIndex the first column is 1, the second is 2...
return encoding.decode(this_row[columnIndex - 1]);
}
- /**
+ /*
* Get the value of a column in the current row as a Java boolean
*
* @param columnIndex the first column is 1, the second is 2...
return false; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a Java byte.
*
* @param columnIndex the first column is 1, the second is 2,...
return 0; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a Java short.
*
* @param columnIndex the first column is 1, the second is 2,...
return 0; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a Java int.
*
* @param columnIndex the first column is 1, the second is 2,...
return 0; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a Java long.
*
* @param columnIndex the first column is 1, the second is 2,...
return 0; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a Java float.
*
* @param columnIndex the first column is 1, the second is 2,...
return 0; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a Java double.
*
* @param columnIndex the first column is 1, the second is 2,...
return 0; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a
* java.math.BigDecimal object
*
return null; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a Java byte array.
*
* <p>In normal use, the bytes represent the raw values returned by the
return null;
}
- /**
+ /*
* Get the value of a column in the current row as a java.sql.Date
* object
*
}
}
- /**
+ /*
* Get the value of a column in the current row as a java.sql.Time
* object
*
return null; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a
* java.sql.Timestamp object
*
}
}
- /**
+ /*
* A column value can be retrieved as a stream of ASCII characters
* and then read in chunks from the stream. This method is
* particular suitable for retrieving large LONGVARCHAR values.
}
}
- /**
+ /*
* A column value can also be retrieved as a stream of Unicode
* characters. We implement this as a binary stream.
*
}
}
- /**
+ /*
* A column value can also be retrieved as a binary strea. This
* method is suitable for retrieving LONGVARBINARY values.
*
return null;
}
- /**
+ /*
* The following routines simply convert the columnName into
* a columnIndex and then call the appropriate routine above.
*
return getBinaryStream(findColumn(columnName));
}
- /**
+ /*
* The first warning reported by calls on this ResultSet is
* returned. Subsequent ResultSet warnings will be chained
* to this SQLWarning.
return warnings;
}
- /**
+ /*
* After this call, getWarnings returns null until a new warning
* is reported for this ResultSet
*
warnings = null;
}
- /**
+ /*
* Get the name of the SQL cursor used by this ResultSet
*
* <p>In SQL, a result table is retrieved though a cursor that is
return connection.getCursorName();
}
- /**
+ /*
* The numbers, types and properties of a ResultSet's columns are
* provided by the getMetaData method
*
return new ResultSetMetaData(rows, fields);
}
- /**
+ /*
* Get the value of a column in the current row as a Java object
*
* <p>This method will return the value of the given column as a
}
}
- /**
+ /*
* Get the value of a column in the current row as a Java object
*
*<p> This method will return the value of the given column as a
return getObject(findColumn(columnName));
}
- /**
+ /*
* Map a ResultSet column name to a ResultSet column index
*
* @param columnName the name of the column
import java.sql.SQLException;
import java.sql.Types;
-/**
+/*
* A ResultSetMetaData object can be used to find out about the types and
* properties of the columns in a ResultSet
*
Vector rows;
Field[] fields;
- /**
+ /*
* Initialise for a result with a tuple set and
* a field descriptor set
*
this.fields = fields;
}
- /**
+ /*
* Whats the number of columns in the ResultSet?
*
* @return the number
return fields.length;
}
- /**
+ /*
* Is the column automatically numbered (and thus read-only)
* I believe that PostgreSQL does not support this feature.
*
return false;
}
- /**
+ /*
* Does a column's case matter? ASSUMPTION: Any field that is
* not obviously case insensitive is assumed to be case sensitive
*
}
}
- /**
+ /*
* Can the column be used in a WHERE clause? Basically for
* this, I split the functions into two types: recognised
* types (which are always useable), and OTHER types (which
}
}
- /**
+ /*
* Is the column a cash value? 6.1 introduced the cash/money
* type, which haven't been incorporated as of 970414, so I
* just check the type name for both 'cash' and 'money'
return type_name.equals("cash") || type_name.equals("money");
}
- /**
+ /*
* Indicates the nullability of values in the designated column.
*
* @param column the first column is 1, the second is 2...
return columnNullableUnknown;
}
- /**
+ /*
* Is the column a signed number? In PostgreSQL, all numbers
* are signed, so this is trivial. However, strings are not
* signed (duh!)
}
}
- /**
+ /*
* What is the column's normal maximum width in characters?
*
* @param column the first column is 1, the second is 2, etc.
return f.getLength();
}
- /**
+ /*
* What is the suggested column title for use in printouts and
* displays? We suggest the ColumnName!
*
return getColumnName(column);
}
- /**
+ /*
* What's a column's name?
*
* @param column the first column is 1, the second is 2, etc.
return "field" + column;
}
- /**
+ /*
* What is a column's table's schema? This relies on us knowing
* the table name....which I don't know how to do as yet. The
* JDBC specification allows us to return "" if this is not
return "";
}
- /**
+ /*
* What is a column's number of decimal digits.
*
* @param column the first column is 1, the second is 2...
}
}
- /**
+ /*
* What is a column's number of digits to the right of the
* decimal point?
*
}
}
- /**
+ /*
* Whats a column's table's name? How do I find this out? Both
* getSchemaName() and getCatalogName() rely on knowing the table
* Name, so we need this before we can work on them.
return "";
}
- /**
+ /*
* What's a column's table's catalog name? As with getSchemaName(),
* we can say that if getTableName() returns n/a, then we can too -
* otherwise, we need to work on it.
return "";
}
- /**
+ /*
* What is a column's SQL Type? (java.sql.Type int)
*
* @param column the first column is 1, the second is 2, etc.
return getField(column).getSQLType();
}
- /**
+ /*
* Whats is the column's data source specific type name?
*
* @param column the first column is 1, the second is 2, etc.
return getField(column).getPGType();
}
- /**
+ /*
* Is the column definitely not writable? In reality, we would
* have to check the GRANT/REVOKE stuff for this to be effective,
* and I haven't really looked into that yet, so this will get
return false;
}
- /**
+ /*
* Is it possible for a write on the column to succeed? Again, we
* would in reality have to check the GRANT/REVOKE stuff, which
* I haven't worked with as yet. However, if it isn't ReadOnly, then
return !isReadOnly(column);
}
- /**
+ /*
* Will a write on this column definately succeed? Hmmm...this
* is a bad one, since the two preceding functions have not been
* really defined. I cannot tell is the short answer. I thus
// END OF PUBLIC INTERFACE
// ********************************************************
- /**
+ /*
* For several routines in this package, we need to convert
* a columnIndex into a Field[] descriptor. Rather than do
* the same code several times, here it is.
import org.postgresql.util.PSQLException;
-/**
+/*
* A Statement object is used for executing a static SQL statement and
* obtaining the results produced by it.
*
{
private Connection connection; // The connection who created us
- /**
+ /*
* Constructor for a Statement. It simply sets the connection
* that created us.
*
connection = c;
}
- /**
+ /*
* Execute a SQL statement that retruns a single ResultSet
*
* @param sql typically a static SQL SELECT statement
return result;
}
- /**
+ /*
* Execute a SQL INSERT, UPDATE or DELETE statement. In addition
* SQL statements that return nothing such as SQL DDL statements
* can be executed
return this.getUpdateCount();
}
- /**
+ /*
* 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
connection.setCursorName(name);
}
- /**
+ /*
* Execute a SQL statement that may return multiple results. We
* don't have to worry about this since we do not support multiple
* ResultSets. You can use getResultSet or getUpdateCount to
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.
return ((org.postgresql.ResultSet)result).getResultCount();
}
- /**
+ /*
* getMoreResults moves to a Statement's next result. If it returns
* true, this result is a ResulSet.
*
import org.postgresql.Field;
import org.postgresql.util.*;
-/**
+/*
* Array is used collect one column of query result data.
*
* <p>Read a field of type Array into either a natively-typed
private int idx = 0;
private String rawString = null;
- /**
+ /*
* Create a new Array
*
* @param conn a database connection
import java.sql.*;
import java.math.*;
-/**
+/*
* CallableStatement is used to execute SQL stored procedures.
*
* <p>JDBC provides a stored procedure SQL escape that allows stored
public class CallableStatement extends org.postgresql.jdbc2.PreparedStatement implements java.sql.CallableStatement
{
- /**
+ /*
* @exception SQLException on failure
*/
public CallableStatement(Connection c, String q) throws SQLException
super(c, q);
}
- /**
+ /*
* Before executing a stored procedure call you must explicitly
* call registerOutParameter to register the java.sql.Type of each
* out parameter.
public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException
{}
- /**
+ /*
* You must also specify the scale for numeric/decimal types:
*
* <p>Note: When reading the value of an out parameter, you must use
//return true;
//}
- /**
+ /*
* An OUT parameter may have the value of SQL NULL; wasNull
* reports whether the last value read has this special value.
*
//return null;
//}
- /**
+ /*
* Get the value of a CHAR, VARCHAR, or LONGVARCHAR parameter as a
* Java String.
*
//return null;
//}
- /**
+ /*
* Get the value of a BIT parameter as a Java boolean.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return false;
}
- /**
+ /*
* Get the value of a TINYINT parameter as a Java byte.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0;
}
- /**
+ /*
* Get the value of a SMALLINT parameter as a Java short.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0;
}
- /**
+ /*
* Get the value of an INTEGER parameter as a Java int.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0;
}
- /**
+ /*
* Get the value of a BIGINT parameter as a Java long.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0;
}
- /**
+ /*
* Get the value of a FLOAT parameter as a Java float.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return (float) 0.0;
}
- /**
+ /*
* Get the value of a DOUBLE parameter as a Java double.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return 0.0;
}
- /**
+ /*
* Get the value of a NUMERIC parameter as a java.math.BigDecimal
* object.
*
return null;
}
- /**
+ /*
* Get the value of a SQL BINARY or VARBINARY parameter as a Java
* byte[]
*
//return null;
//}
- /**
+ /*
* Get the value of a SQL DATE parameter as a java.sql.Date object
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return null;
}
- /**
+ /*
* Get the value of a SQL TIME parameter as a java.sql.Time object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
return null;
}
- /**
+ /*
* Get the value of a SQL TIMESTAMP parameter as a java.sql.Timestamp object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
// getObject returns a Java object for the parameter.
// See the JDBC spec's "Dynamic Programming" chapter for details.
- /**
+ /*
* Get the value of a parameter as a Java object.
*
* <p>This method returns a Java object whose type coresponds to the
import org.postgresql.largeobject.*;
import org.postgresql.util.*;
-/**
- * $Id: Connection.java,v 1.14 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: Connection.java,v 1.15 2001/11/19 22:33:38 momjian Exp $
*
* A Connection represents a session with a specific database. Within the
* context of a Connection, SQL statements are executed and results are
// This is a cache of the DatabaseMetaData instance for this connection
protected DatabaseMetaData metadata;
- /**
+ /*
* The current type mappings
*/
protected java.util.Map typemap;
- /**
+ /*
* SQL statements without parameters are normally executed using
* Statement objects. If the same SQL statement is executed many
* times, it is more efficient to use a PreparedStatement
return createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE, java.sql.ResultSet.CONCUR_READ_ONLY);
}
- /**
+ /*
* SQL statements without parameters are normally executed using
* Statement objects. If the same SQL statement is executed many
* times, it is more efficient to use a PreparedStatement
}
- /**
+ /*
* A SQL statement with or without IN parameters can be pre-compiled
* and stored in a PreparedStatement object. This object can then
* be used to efficiently execute this statement multiple times.
return s;
}
- /**
+ /*
* A SQL stored procedure call statement is handled by creating a
* CallableStatement for it. The CallableStatement provides methods
* for setting up its IN and OUT parameters and methods for executing
//return s;
}
- /**
+ /*
* Tests to see if a Connection is closed.
*
* Peter Feb 7 2000: Now I've discovered that this doesn't actually obey the
}
}
- /**
+ /*
* A connection's database is able to provide information describing
* its tables, its supported SQL grammar, its stored procedures, the
* capabilities of this connection, etc. This information is made
return metadata;
}
- /**
+ /*
* This overides the method in org.postgresql.Connection and returns a
* ResultSet.
*/
typemap = map;
}
- /**
+ /*
* This overides the standard internal getObject method so that we can
* check the jdbc2 type map first
*
return sqlType;
}
- /**
+ /*
* This table holds the org.postgresql names for the types supported.
* Any types that map to Types.OTHER (eg POINT) don't go into this table.
* They default automatically to Types.OTHER
"_bytea"
};
- /**
+ /*
* This table holds the JDBC type for each entry above.
*
* Note: This must be in the same order as above
import org.postgresql.Field;
import org.postgresql.util.PSQLException;
-/**
+/*
* This class provides information about the database as a whole.
*
- * $Id: DatabaseMetaData.java,v 1.45 2001/11/14 20:04:00 davec Exp $
+ * $Id: DatabaseMetaData.java,v 1.46 2001/11/19 22:33:39 momjian Exp $
*
* <p>Many of the methods here return lists of information in ResultSets. You
* can use the normal ResultSet methods such as getString and getInt to
this.connection = conn;
}
- /**
+ /*
* Can all the procedures returned by getProcedures be called
* by the current user?
*
*/
public boolean allProceduresAreCallable() throws SQLException
{
- Driver.debug("allProceduresAreCallable");
+ Driver.debug("allProceduresAreCallable");
return true; // For now...
}
- /**
+ /*
* Can all the tables returned by getTable be SELECTed by
* the current user?
*
*/
public boolean allTablesAreSelectable() throws SQLException
{
- Driver.debug("allTablesAreSelectable");
+ Driver.debug("allTablesAreSelectable");
return true; // For now...
}
- /**
+ /*
* What is the URL for this database?
*
* @return the url or null if it cannott be generated
*/
public String getURL() throws SQLException
{
- String url = connection.getURL();
- Driver.debug("getURL "+url);
- return url;
+ String url = connection.getURL();
+ Driver.debug("getURL "+url);
+ return url;
}
- /**
+ /*
* What is our user name as known to the database?
*
* @return our database user name
*/
public String getUserName() throws SQLException
{
- String userName = connection.getUserName();
- Driver.debug("getUserName "+ userName);
- return userName;
+ String userName = connection.getUserName();
+ Driver.debug("getUserName "+ userName);
+ return userName;
}
- /**
+ /*
* Is the database in read-only mode?
*
* @return true if so
*/
public boolean isReadOnly() throws SQLException
{
- boolean isReadOnly = connection.isReadOnly();
- Driver.debug("isReadOnly " +isReadOnly);
- return isReadOnly;
+ boolean isReadOnly = connection.isReadOnly();
+ Driver.debug("isReadOnly " +isReadOnly);
+ return isReadOnly;
}
- /**
+ /*
* Are NULL values sorted high?
*
* @return true if so
*/
public boolean nullsAreSortedHigh() throws SQLException
{
- boolean nullSortedHigh = connection.haveMinimumServerVersion("7.2");
- Driver.debug("nullsAreSortedHigh " + nullSortedHigh);
- return nullSortedHigh;
+ boolean nullSortedHigh = connection.haveMinimumServerVersion("7.2");
+ Driver.debug("nullsAreSortedHigh " + nullSortedHigh);
+ return nullSortedHigh;
}
- /**
+ /*
* Are NULL values sorted low?
*
* @return true if so
*/
public boolean nullsAreSortedLow() throws SQLException
{
- Driver.debug("nullsAreSortedLow false");
+ Driver.debug("nullsAreSortedLow false");
return false;
}
- /**
+ /*
* Are NULL values sorted at the start regardless of sort order?
*
* @return true if so
*/
public boolean nullsAreSortedAtStart() throws SQLException
{
- Driver.debug("nullsAreSortedAtStart false");
+ Driver.debug("nullsAreSortedAtStart false");
return false;
}
- /**
+ /*
* Are NULL values sorted at the end regardless of sort order?
*
* @return true if so
*/
public boolean nullsAreSortedAtEnd() throws SQLException
{
- boolean nullsAreSortedAtEnd = ! connection.haveMinimumServerVersion("7.2");
- Driver.debug("nullsAreSortedAtEnd "+nullsAreSortedAtEnd);
- return nullsAreSortedAtEnd;
+ boolean nullsAreSortedAtEnd = ! connection.haveMinimumServerVersion("7.2");
+ Driver.debug("nullsAreSortedAtEnd "+nullsAreSortedAtEnd);
+ return nullsAreSortedAtEnd;
}
- /**
+ /*
* What is the name of this database product - we hope that it is
* PostgreSQL, so we return that explicitly.
*
*/
public String getDatabaseProductName() throws SQLException
{
- Driver.debug("getDatabaseProductName PostgresSQL");
+ Driver.debug("getDatabaseProductName PostgresSQL");
return "PostgreSQL";
}
- /**
+ /*
* What is the version of this database product.
*
* @return the database version
*/
public String getDatabaseProductVersion() throws SQLException
{
- String versionNumber = connection.getDBVersionNumber();
- Driver.debug("getDatabaseProductVersion " + versionNumber);
- return versionNumber;
+ String versionNumber = connection.getDBVersionNumber();
+ Driver.debug("getDatabaseProductVersion " + versionNumber);
+ return versionNumber;
}
- /**
+ /*
* What is the name of this JDBC driver? If we don't know this
* we are doing something wrong!
*
*/
public String getDriverName() throws SQLException
{
- String driverName = "PostgreSQL Native Driver";
- Driver.debug("getDriverName" + driverName);
- return driverName;
- }
+ String driverName = "PostgreSQL Native Driver";
+ Driver.debug("getDriverName" + driverName);
+ return driverName;
+ }
- /**
- * What is the version string of this JDBC driver? Again, this is
+ /*
+ * What is the version string of this JDBC driver? Again, this is
* static.
*
* @return the JDBC driver name.
*/
public String getDriverVersion() throws SQLException
{
- String driverVersion = connection.this_driver.getVersion();
- Driver.debug("getDriverVersion "+driverVersion);
- return driverVersion;
+ String driverVersion = connection.this_driver.getVersion();
+ Driver.debug("getDriverVersion "+driverVersion);
+ return driverVersion;
}
- /**
+ /*
* What is this JDBC driver's major version number?
*
* @return the JDBC driver major version
*/
public int getDriverMajorVersion()
{
- int majorVersion = connection.this_driver.getMajorVersion();
- Driver.debug("getMajorVersion " +majorVersion);
- return majorVersion;
+ int majorVersion = connection.this_driver.getMajorVersion();
+ Driver.debug("getMajorVersion " +majorVersion);
+ return majorVersion;
}
- /**
+ /*
* What is this JDBC driver's minor version number?
*
* @return the JDBC driver minor version
*/
public int getDriverMinorVersion()
{
- int minorVersion = connection.this_driver.getMinorVersion();
- Driver.debug("getMinorVersion " +minorVersion);
- return minorVersion;
- }
+ int minorVersion = connection.this_driver.getMinorVersion();
+ Driver.debug("getMinorVersion " +minorVersion);
+ return minorVersion;
+ }
- /**
- * Does the database store tables in a local file? No - it
+ /*
+ * Does the database store tables in a local file? No - it
* stores them in a file on the server.
*
* @return true if so
*/
public boolean usesLocalFiles() throws SQLException
{
- Driver.debug("usesLocalFiles " + false);
+ Driver.debug("usesLocalFiles " + false);
return false;
}
- /**
+ /*
* Does the database use a file for each table? Well, not really,
* since it doesnt use local files.
*
*/
public boolean usesLocalFilePerTable() throws SQLException
{
- Driver.debug("usesLocalFilePerTable " + false);
+ Driver.debug("usesLocalFilePerTable " + false);
return false;
}
- /**
+ /*
* Does the database treat mixed case unquoted SQL identifiers
* as case sensitive and as a result store them in mixed case?
* A JDBC-Compliant driver will always return false.
*/
public boolean supportsMixedCaseIdentifiers() throws SQLException
{
- Driver.debug("supportsMixedCaseIdentifiers " + false);
+ Driver.debug("supportsMixedCaseIdentifiers " + false);
return false;
}
- /**
+ /*
* Does the database treat mixed case unquoted SQL identifiers as
* case insensitive and store them in upper case?
*
*/
public boolean storesUpperCaseIdentifiers() throws SQLException
{
- Driver.debug("storesUpperCaseIdentifiers "+false);
+ Driver.debug("storesUpperCaseIdentifiers "+false);
return false;
}
- /**
+ /*
* Does the database treat mixed case unquoted SQL identifiers as
* case insensitive and store them in lower case?
*
*/
public boolean storesLowerCaseIdentifiers() throws SQLException
{
- Driver.debug("storesLowerCaseIdentifiers " + true);
+ Driver.debug("storesLowerCaseIdentifiers " + true);
return true;
}
- /**
+ /*
* Does the database treat mixed case unquoted SQL identifiers as
* case insensitive and store them in mixed case?
*
*/
public boolean storesMixedCaseIdentifiers() throws SQLException
{
- Driver.debug("storesMixedCaseIdentifiers " + false);
+ Driver.debug("storesMixedCaseIdentifiers " + false);
return false;
}
- /**
+ /*
* Does the database treat mixed case quoted SQL identifiers as
* case sensitive and as a result store them in mixed case? A
* JDBC compliant driver will always return true.
*/
public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException
{
- Driver.debug("supportsMixedCaseQuotedIdentifiers " + true);
+ Driver.debug("supportsMixedCaseQuotedIdentifiers " + true);
return true;
}
- /**
+ /*
* Does the database treat mixed case quoted SQL identifiers as
* case insensitive and store them in upper case?
*
*/
public boolean storesUpperCaseQuotedIdentifiers() throws SQLException
{
- Driver.debug("storesUpperCaseQuotedIdentifiers " + false);
+ Driver.debug("storesUpperCaseQuotedIdentifiers " + false);
return false;
}
- /**
+ /*
* Does the database treat mixed case quoted SQL identifiers as case
* insensitive and store them in lower case?
*
*/
public boolean storesLowerCaseQuotedIdentifiers() throws SQLException
{
- Driver.debug("storesLowerCaseQuotedIdentifiers " + false);
+ Driver.debug("storesLowerCaseQuotedIdentifiers " + false);
return false;
}
- /**
+ /*
* Does the database treat mixed case quoted SQL identifiers as case
* insensitive and store them in mixed case?
*
*/
public boolean storesMixedCaseQuotedIdentifiers() throws SQLException
{
- Driver.debug("storesMixedCaseQuotedIdentifiers " + false);
+ Driver.debug("storesMixedCaseQuotedIdentifiers " + false);
return false;
}
- /**
+ /*
* What is the string used to quote SQL identifiers? This returns
* a space if identifier quoting isn't supported. A JDBC Compliant
* driver will always use a double quote character.
*/
public String getIdentifierQuoteString() throws SQLException
{
- Driver.debug("getIdentifierQuoteString \"" );
+ Driver.debug("getIdentifierQuoteString \"" );
return "\"";
}
- /**
+ /*
* Get a comma separated list of all a database's SQL keywords that
* are NOT also SQL92 keywords.
*
*/
public String getSQLKeywords() throws SQLException
{
- Driver.debug("getSQLKeyWords");
+ Driver.debug("getSQLKeyWords");
return "abort,acl,add,aggregate,append,archive,arch_store,backward,binary,change,cluster,copy,database,delimiters,do,extend,explain,forward,heavy,index,inherits,isnull,light,listen,load,merge,nothing,notify,notnull,oids,purge,rename,replace,retrieve,returns,rule,recipe,setof,stdin,stdout,store,vacuum,verbose,version";
}
public String getNumericFunctions() throws SQLException
{
// XXX-Not Implemented
- Driver.debug("getNumericFunctions");
+ Driver.debug("getNumericFunctions");
return "";
}
public String getStringFunctions() throws SQLException
{
// XXX-Not Implemented
- Driver.debug("getStringFunctions");
+ Driver.debug("getStringFunctions");
return "";
}
public String getSystemFunctions() throws SQLException
{
// XXX-Not Implemented
- Driver.debug("getSystemFunctions");
+ Driver.debug("getSystemFunctions");
return "";
}
public String getTimeDateFunctions() throws SQLException
{
// XXX-Not Implemented
- Driver.debug("getTimeDateFunctions");
+ Driver.debug("getTimeDateFunctions");
return "";
}
- /**
+ /*
* This is the string that can be used to escape '_' and '%' in
* a search string pattern style catalog search parameters
*
*/
public String getSearchStringEscape() throws SQLException
{
- Driver.debug("getSearchStringEscape");
+ Driver.debug("getSearchStringEscape");
return "\\";
}
- /**
+ /*
* Get all the "extra" characters that can be used in unquoted
* identifier names (those beyond a-zA-Z0-9 and _)
*
*/
public String getExtraNameCharacters() throws SQLException
{
- Driver.debug("getExtraNameCharacters");
+ Driver.debug("getExtraNameCharacters");
return "";
}
- /**
+ /*
* Is "ALTER TABLE" with an add column supported?
* Yes for PostgreSQL 6.1
*
*/
public boolean supportsAlterTableWithAddColumn() throws SQLException
{
- Driver.debug("supportsAlterTableWithAddColumn " + true);
+ Driver.debug("supportsAlterTableWithAddColumn " + true);
return true;
}
- /**
+ /*
* Is "ALTER TABLE" with a drop column supported?
* Peter 10/10/2000 This was set to true, but 7.1devel doesn't support it!
*
*/
public boolean supportsAlterTableWithDropColumn() throws SQLException
{
- Driver.debug("supportsAlterTableWithDropColumn " + false);
+ Driver.debug("supportsAlterTableWithDropColumn " + false);
return false;
}
- /**
+ /*
* Is column aliasing supported?
*
* <p>If so, the SQL AS clause can be used to provide names for
*/
public boolean supportsColumnAliasing() throws SQLException
{
- Driver.debug("supportsColumnAliasing " + true);
+ Driver.debug("supportsColumnAliasing " + true);
return true;
}
- /**
+ /*
* Are concatenations between NULL and non-NULL values NULL? A
* JDBC Compliant driver always returns true
*
*/
public boolean nullPlusNonNullIsNull() throws SQLException
{
- Driver.debug("nullPlusNonNullIsNull " + true);
+ Driver.debug("nullPlusNonNullIsNull " + true);
return true;
}
public boolean supportsConvert() throws SQLException
{
// XXX-Not Implemented
- Driver.debug("supportsConvert " + false);
+ Driver.debug("supportsConvert " + false);
return false;
}
public boolean supportsConvert(int fromType, int toType) throws SQLException
{
// XXX-Not Implemented
- Driver.debug("supportsConvert " + false);
+ Driver.debug("supportsConvert " + false);
return false;
}
- /**
+ /*
* Are table correlation names supported? A JDBC Compliant
* driver always returns true.
*
*/
public boolean supportsTableCorrelationNames() throws SQLException
{
- Driver.debug("supportsTableCorrelationNames " + true);
+ Driver.debug("supportsTableCorrelationNames " + true);
return true;
}
- /**
+ /*
* If table correlation names are supported, are they restricted to
* be different from the names of the tables?
*
*/
public boolean supportsDifferentTableCorrelationNames() throws SQLException
{
- Driver.debug("supportsDifferentTableCorrelationNames " + false);
+ Driver.debug("supportsDifferentTableCorrelationNames " + false);
return false;
}
- /**
+ /*
* Are expressions in "ORDER BY" lists supported?
*
* <br>e.g. select * from t order by a + b;
*/
public boolean supportsExpressionsInOrderBy() throws SQLException
{
- Driver.debug("supportsExpressionsInOrderBy " + true);
+ Driver.debug("supportsExpressionsInOrderBy " + true);
return true;
}
- /**
+ /*
* Can an "ORDER BY" clause use columns not in the SELECT?
*
* @return true if so
*/
public boolean supportsOrderByUnrelated() throws SQLException
{
- boolean supportsOrderByUnrelated = connection.haveMinimumServerVersion("6.4");
- Driver.debug("supportsOrderByUnrelated " + supportsOrderByUnrelated);
- return supportsOrderByUnrelated;
+ boolean supportsOrderByUnrelated = connection.haveMinimumServerVersion("6.4");
+ Driver.debug("supportsOrderByUnrelated " + supportsOrderByUnrelated);
+ return supportsOrderByUnrelated;
}
- /**
+ /*
* Is some form of "GROUP BY" clause supported?
* I checked it, and yes it is.
*
*/
public boolean supportsGroupBy() throws SQLException
{
- Driver.debug("supportsGroupBy " + true);
+ Driver.debug("supportsGroupBy " + true);
return true;
}
- /**
+ /*
* Can a "GROUP BY" clause use columns not in the SELECT?
*
* @return true if so
*/
public boolean supportsGroupByUnrelated() throws SQLException
{
- boolean supportsGroupByUnrelated = connection.haveMinimumServerVersion("6.4");
- Driver.debug("supportsGroupByUnrelated "+ supportsGroupByUnrelated);
- return supportsGroupByUnrelated;
-
+ boolean supportsGroupByUnrelated = connection.haveMinimumServerVersion("6.4");
+ Driver.debug("supportsGroupByUnrelated "+ supportsGroupByUnrelated);
+ return supportsGroupByUnrelated;
}
- /**
+ /*
* Can a "GROUP BY" clause add columns not in the SELECT provided
- * it specifies all the columns in the SELECT? Does anyone actually
+ * it specifies all the columns in the SELECT? Does anyone actually
* understand what they mean here?
*
* (I think this is a subset of the previous function. -- petere)
*/
public boolean supportsGroupByBeyondSelect() throws SQLException
{
- boolean supportsGroupByBeyondSelect = connection.haveMinimumServerVersion("6.4");
- Driver.debug("supportsGroupByUnrelated " + supportsGroupByBeyondSelect);
- return supportsGroupByBeyondSelect;
+ boolean supportsGroupByBeyondSelect = connection.haveMinimumServerVersion("6.4");
+ Driver.debug("supportsGroupByUnrelated " + supportsGroupByBeyondSelect);
+ return supportsGroupByBeyondSelect;
}
- /**
+ /*
* Is the escape character in "LIKE" clauses supported? A
* JDBC compliant driver always returns true.
*
*/
public boolean supportsLikeEscapeClause() throws SQLException
{
- boolean supportsLikeEscapeClause = connection.haveMinimumServerVersion("7.1");
- Driver.debug("supportsLikeEscapeClause " + supportsLikeEscapeClause);
- return supportsLikeEscapeClause;
+ boolean supportsLikeEscapeClause = connection.haveMinimumServerVersion("7.1");
+ Driver.debug("supportsLikeEscapeClause " + supportsLikeEscapeClause);
+ return supportsLikeEscapeClause;
}
- /**
+ /*
* Are multiple ResultSets from a single execute supported?
* Well, I implemented it, but I dont think this is possible from
* the back ends point of view.
*/
public boolean supportsMultipleResultSets() throws SQLException
{
- Driver.debug("supportsMultipleResultSets " + false);
+ Driver.debug("supportsMultipleResultSets " + false);
return false;
}
- /**
+ /*
* Can we have multiple transactions open at once (on different
* connections?)
* I guess we can have, since Im relying on it.
*/
public boolean supportsMultipleTransactions() throws SQLException
{
- Driver.debug("supportsMultipleTransactions " + true);
- return true;
- }
+ Driver.debug("supportsMultipleTransactions " + true);
+ return true;
+ }
- /**
- * Can columns be defined as non-nullable. A JDBC Compliant driver
+ /*
+ * Can columns be defined as non-nullable. A JDBC Compliant driver
* always returns true.
*
* <p>This changed from false to true in v6.2 of the driver, as this
*/
public boolean supportsNonNullableColumns() throws SQLException
{
- Driver.debug("supportsNonNullableColumns true");
+ Driver.debug("supportsNonNullableColumns true");
return true;
}
- /**
+ /*
* Does this driver support the minimum ODBC SQL grammar. This
* grammar is defined at:
*
*/
public boolean supportsMinimumSQLGrammar() throws SQLException
{
- Driver.debug("supportsMinimumSQLGrammar TRUE");
- return true;
- }
+ Driver.debug("supportsMinimumSQLGrammar TRUE");
+ return true;
+ }
- /**
- * Does this driver support the Core ODBC SQL grammar. We need
+ /*
+ * Does this driver support the Core ODBC SQL grammar. We need
* SQL-92 conformance for this.
*
* @return true if so
*/
public boolean supportsCoreSQLGrammar() throws SQLException
{
- Driver.debug("supportsCoreSQLGrammar FALSE ");
+ Driver.debug("supportsCoreSQLGrammar FALSE ");
return false;
}
- /**
+ /*
* Does this driver support the Extended (Level 2) ODBC SQL
* grammar. We don't conform to the Core (Level 1), so we can't
* conform to the Extended SQL Grammar.
*/
public boolean supportsExtendedSQLGrammar() throws SQLException
{
- Driver.debug("supportsExtendedSQLGrammar FALSE");
+ Driver.debug("supportsExtendedSQLGrammar FALSE");
return false;
}
- /**
+ /*
* Does this driver support the ANSI-92 entry level SQL grammar?
* All JDBC Compliant drivers must return true. We currently
* report false until 'schema' support is added. Then this
*/
public boolean supportsANSI92EntryLevelSQL() throws SQLException
{
- Driver.debug("supportsANSI92EntryLevelSQL false ");
+ Driver.debug("supportsANSI92EntryLevelSQL false ");
return false;
}
- /**
+ /*
* Does this driver support the ANSI-92 intermediate level SQL
* grammar?
*
*/
public boolean supportsANSI92IntermediateSQL() throws SQLException
{
- Driver.debug("supportsANSI92IntermediateSQL false ");
+ Driver.debug("supportsANSI92IntermediateSQL false ");
return false;
}
- /**
+ /*
* Does this driver support the ANSI-92 full SQL grammar?
*
* @return true if so
*/
public boolean supportsANSI92FullSQL() throws SQLException
{
- Driver.debug("supportsANSI92FullSQL false ");
+ Driver.debug("supportsANSI92FullSQL false ");
return false;
}
- /**
+ /*
* Is the SQL Integrity Enhancement Facility supported?
* I haven't seen this mentioned anywhere, so I guess not
*
*/
public boolean supportsIntegrityEnhancementFacility() throws SQLException
{
- Driver.debug("supportsIntegrityEnhancementFacility false ");
+ Driver.debug("supportsIntegrityEnhancementFacility false ");
return false;
}
- /**
+ /*
* Is some form of outer join supported?
*
* @return true if so
*/
public boolean supportsOuterJoins() throws SQLException
{
- boolean supportsOuterJoins = connection.haveMinimumServerVersion("7.1");
- Driver.debug("supportsOuterJoins " + supportsOuterJoins);
- return supportsOuterJoins;
+ boolean supportsOuterJoins = connection.haveMinimumServerVersion("7.1");
+ Driver.debug("supportsOuterJoins " + supportsOuterJoins);
+ return supportsOuterJoins;
}
- /**
+ /*
* Are full nexted outer joins supported?
*
* @return true if so
*/
public boolean supportsFullOuterJoins() throws SQLException
{
- boolean supportsFullOuterJoins = connection.haveMinimumServerVersion("7.1");
- Driver.debug("supportsFullOuterJoins " + supportsFullOuterJoins);
- return supportsFullOuterJoins;
+ boolean supportsFullOuterJoins = connection.haveMinimumServerVersion("7.1");
+ Driver.debug("supportsFullOuterJoins " + supportsFullOuterJoins);
+ return supportsFullOuterJoins;
}
- /**
+ /*
* Is there limited support for outer joins?
*
* @return true if so
*/
public boolean supportsLimitedOuterJoins() throws SQLException
{
- boolean supportsLimitedOuterJoins = connection.haveMinimumServerVersion("7.1");
- Driver.debug("supportsFullOuterJoins " + supportsLimitedOuterJoins);
- return supportsLimitedOuterJoins;
+ boolean supportsLimitedOuterJoins = connection.haveMinimumServerVersion("7.1");
+ Driver.debug("supportsFullOuterJoins " + supportsLimitedOuterJoins);
+ return supportsLimitedOuterJoins;
}
- /**
+ /*
* What is the database vendor's preferred term for "schema"?
* PostgreSQL doesn't have schemas, but when it does, we'll use the
* term "schema".
*/
public String getSchemaTerm() throws SQLException
{
- Driver.debug("getSchemaTerm schema");
+ Driver.debug("getSchemaTerm schema");
return "schema";
}
- /**
+ /*
* What is the database vendor's preferred term for "procedure"?
* Traditionally, "function" has been used.
*
*/
public String getProcedureTerm() throws SQLException
{
- Driver.debug("getProcedureTerm function ");
+ Driver.debug("getProcedureTerm function ");
return "function";
}
- /**
+ /*
* What is the database vendor's preferred term for "catalog"?
*
* @return the vendor term
*/
public String getCatalogTerm() throws SQLException
{
- Driver.debug("getCatalogTerm database ");
+ Driver.debug("getCatalogTerm database ");
return "database";
}
- /**
+ /*
* Does a catalog appear at the start of a qualified table name?
* (Otherwise it appears at the end).
*
*/
public boolean isCatalogAtStart() throws SQLException
{
- // return true here; we return false for every other catalog function
- // so it won't matter what we return here D.C.
- Driver.debug("isCatalogAtStart not implemented");
- return true;
+ // return true here; we return false for every other catalog function
+ // so it won't matter what we return here D.C.
+ Driver.debug("isCatalogAtStart not implemented");
+ return true;
}
- /**
+ /*
* What is the Catalog separator.
*
* @return the catalog separator string
*/
public String getCatalogSeparator() throws SQLException
{
- // Give them something to work with here
- // everything else returns false so it won't matter what we return here D.C.
- Driver.debug("getCatalogSeparator not implemented ");
- return ".";
- }
+ // Give them something to work with here
+ // everything else returns false so it won't matter what we return here D.C.
+ Driver.debug("getCatalogSeparator not implemented ");
+ return ".";
+ }
- /**
- * Can a schema name be used in a data manipulation statement? Nope.
+ /*
+ * Can a schema name be used in a data manipulation statement? Nope.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInDataManipulation() throws SQLException
{
- Driver.debug("supportsSchemasInDataManipulation false");
+ Driver.debug("supportsSchemasInDataManipulation false");
return false;
}
- /**
+ /*
* Can a schema name be used in a procedure call statement? Nope.
*
* @return true if so
*/
public boolean supportsSchemasInProcedureCalls() throws SQLException
{
- Driver.debug("supportsSchemasInProcedureCalls false");
+ Driver.debug("supportsSchemasInProcedureCalls false");
return false;
}
- /**
+ /*
* Can a schema be used in a table definition statement? Nope.
*
* @return true if so
*/
public boolean supportsSchemasInTableDefinitions() throws SQLException
{
- Driver.debug("supportsSchemasInTableDefinitions false");
+ Driver.debug("supportsSchemasInTableDefinitions false");
return false;
}
- /**
+ /*
* Can a schema name be used in an index definition statement?
*
* @return true if so
*/
public boolean supportsSchemasInIndexDefinitions() throws SQLException
{
- Driver.debug("supportsSchemasInIndexDefinitions false");
+ Driver.debug("supportsSchemasInIndexDefinitions false");
return false;
}
- /**
+ /*
* Can a schema name be used in a privilege definition statement?
*
* @return true if so
*/
public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException
{
- Driver.debug("supportsSchemasInPrivilegeDefinitions false");
+ Driver.debug("supportsSchemasInPrivilegeDefinitions false");
return false;
}
- /**
+ /*
* Can a catalog name be used in a data manipulation statement?
*
* @return true if so
*/
public boolean supportsCatalogsInDataManipulation() throws SQLException
{
- Driver.debug("supportsCatalogsInDataManipulation false");
+ Driver.debug("supportsCatalogsInDataManipulation false");
return false;
}
- /**
+ /*
* Can a catalog name be used in a procedure call statement?
*
* @return true if so
*/
public boolean supportsCatalogsInProcedureCalls() throws SQLException
{
- Driver.debug("supportsCatalogsInDataManipulation false");
+ Driver.debug("supportsCatalogsInDataManipulation false");
return false;
}
- /**
+ /*
* Can a catalog name be used in a table definition statement?
*
* @return true if so
*/
public boolean supportsCatalogsInTableDefinitions() throws SQLException
{
- Driver.debug("supportsCatalogsInTableDefinitions false");
+ Driver.debug("supportsCatalogsInTableDefinitions false");
return false;
}
- /**
+ /*
* Can a catalog name be used in an index definition?
*
* @return true if so
*/
public boolean supportsCatalogsInIndexDefinitions() throws SQLException
{
- Driver.debug("supportsCatalogsInIndexDefinitions false");
+ Driver.debug("supportsCatalogsInIndexDefinitions false");
return false;
}
- /**
+ /*
* Can a catalog name be used in a privilege definition statement?
*
* @return true if so
*/
public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException
{
- Driver.debug("supportsCatalogsInPrivilegeDefinitions false");
+ Driver.debug("supportsCatalogsInPrivilegeDefinitions false");
return false;
}
- /**
+ /*
* We support cursors for gets only it seems. I dont see a method
* to get a positioned delete.
*
*/
public boolean supportsPositionedDelete() throws SQLException
{
- Driver.debug("supportsPositionedDelete false");
+ Driver.debug("supportsPositionedDelete false");
return false; // For now...
}
- /**
+ /*
* Is positioned UPDATE supported?
*
* @return true if so
*/
public boolean supportsPositionedUpdate() throws SQLException
{
- Driver.debug("supportsPositionedUpdate false");
+ Driver.debug("supportsPositionedUpdate false");
return false; // For now...
}
- /**
+ /*
* Is SELECT for UPDATE supported?
*
* @return true if so; false otherwise
return connection.haveMinimumServerVersion("6.5");
}
- /**
+ /*
* Are stored procedure calls using the stored procedure escape
* syntax supported?
*
return false;
}
- /**
+ /*
* Are subqueries in comparison expressions supported? A JDBC
* Compliant driver always returns true.
*
return true;
}
- /**
+ /*
* Are subqueries in 'exists' expressions supported? A JDBC
* Compliant driver always returns true.
*
return true;
}
- /**
+ /*
* Are subqueries in 'in' statements supported? A JDBC
* Compliant driver always returns true.
*
return true;
}
- /**
+ /*
* Are subqueries in quantified expressions supported? A JDBC
* Compliant driver always returns true.
*
return true;
}
- /**
+ /*
* Are correlated subqueries supported? A JDBC Compliant driver
* always returns true.
*
return connection.haveMinimumServerVersion("7.1");
}
- /**
+ /*
* Is SQL UNION supported?
*
* @return true if so
return true; // since 6.3
}
- /**
+ /*
* Is SQL UNION ALL supported?
*
* @return true if so
return connection.haveMinimumServerVersion("7.1");
}
- /**
+ /*
* In PostgreSQL, Cursors are only open within transactions.
*
* @return true if so
return false;
}
- /**
+ /*
* Do we support open cursors across multiple transactions?
*
* @return true if so
return false;
}
- /**
+ /*
* Can statements remain open across commits? They may, but
* this driver cannot guarentee that. In further reflection.
* we are talking a Statement object here, so the answer is
return true;
}
- /**
+ /*
* Can statements remain open across rollbacks? They may, but
* this driver cannot guarentee that. In further contemplation,
* we are talking a Statement object here, so the answer is yes,
return true;
}
- /**
+ /*
* How many hex characters can you have in an inline binary literal
*
* @return the max literal length
return 0; // no limit
}
- /**
+ /*
* What is the maximum length for a character literal
* I suppose it is 8190 (8192 - 2 for the quotes)
*
return 0; // no limit
}
- /**
+ /*
* Whats the limit on column name length. The description of
* pg_class would say '32' (length of pg_class.relname) - we
* should probably do a query for this....but....
return 32;
}
- /**
+ /*
* What is the maximum number of columns in a "GROUP BY" clause?
*
* @return the max number of columns
return 0; // no limit
}
- /**
+ /*
* What's the maximum number of columns allowed in an index?
* 6.0 only allowed one column, but 6.1 introduced multi-column
* indices, so, theoretically, its all of them.
return getMaxColumnsInTable();
}
- /**
+ /*
* What's the maximum number of columns in an "ORDER BY clause?
*
* @return the max columns
return 0; // no limit
}
- /**
+ /*
* What is the maximum number of columns in a "SELECT" list?
*
* @return the max columns
return 0; // no limit
}
- /**
+ /*
* What is the maximum number of columns in a table? From the
* CREATE TABLE reference page...
*
return 1600;
}
- /**
+ /*
* How many active connection can we have at a time to this
* database? Well, since it depends on postmaster, which just
* does a listen() followed by an accept() and fork(), its
return 8192;
}
- /**
+ /*
* What is the maximum cursor name length (the same as all
* the other F***** identifiers!)
*
return 32;
}
- /**
+ /*
* Retrieves the maximum number of bytes for an index, including all
* of the parts of the index.
*
return 0;
}
- /**
+ /*
* What is the maximum length of a procedure name?
* (length of pg_proc.proname used) - again, I really
* should do a query here to get it.
return 0;
}
- /**
+ /*
* What is the maximum length of a single row?
*
* @return max row size in bytes
return 8192; // XXX could be altered
}
- /**
+ /*
* Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY
* blobs? We don't handle blobs yet
*
return false;
}
- /**
+ /*
* What is the maximum length of a SQL statement?
*
* @return max length in bytes
return 16384;
}
- /**
+ /*
* How many active statements can we have open at one time to
* this database? Basically, since each Statement downloads
* the results as the query is executed, we can have many. However,
return 1;
}
- /**
+ /*
* What is the maximum length of a table name? This was found
* from pg_class.relname length
*
return 32;
}
- /**
+ /*
* What is the maximum number of tables that can be specified
* in a SELECT?
*
return 0; // no limit
}
- /**
+ /*
* What is the maximum length of a user name? Well, we generally
* use UNIX like user names in PostgreSQL, so I think this would
* be 8. However, showing the schema for pg_user shows a length
}
- /**
+ /*
* What is the database's default transaction isolation level? We
* do not support this, so all transactions are SERIALIZABLE.
*
return Connection.TRANSACTION_READ_COMMITTED;
}
- /**
+ /*
* Are transactions supported? If not, commit and rollback are noops
* and the isolation level is TRANSACTION_NONE. We do support
* transactions.
return true;
}
- /**
+ /*
* Does the database support the given transaction isolation level?
* We only support TRANSACTION_SERIALIZABLE and TRANSACTION_READ_COMMITTED
*
return false;
}
- /**
+ /*
* Are both data definition and data manipulation transactions
* supported?
*
return true;
}
- /**
+ /*
* Are only data manipulation statements withing a transaction
* supported?
*
return false;
}
- /**
+ /*
* Does a data definition statement within a transaction force
* the transaction to commit? I think this means something like:
*
return false;
}
- /**
+ /*
* Is a data definition statement within a transaction ignored?
* It seems to be (from experiment in previous method)
*
return true;
}
- /**
+ /*
* Get a description of stored procedures available in a catalog
*
* <p>Only procedure descriptions matching the schema and procedure
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of a catalog's stored procedure parameters
* and result columns.
*
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of tables available in a catalog.
*
* <p>Only table descriptions matching the catalog, schema, table
"TABLE", "VIEW", "INDEX", "SEQUENCE"
};
- /**
+ /*
* Get the schema names available in this database. The results
* are ordered by schema name.
*
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get the catalog names available in this database. The results
* are ordered by catalog name.
*
return connection.createStatement().executeQuery("select datname as TABLE_CAT from pg_database;");
}
- /**
+ /*
* Get the table types available in this database. The results
* are ordered by table type.
*
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of table columns available in a catalog.
*
* <P>Only column descriptions matching the catalog, schema, table
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of the access rights for a table's columns.
*
* <P>Only privileges matching the column name criteria are
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of the access rights for each table available
* in a catalog.
*
*/
public java.sql.ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException
{
- Field f[] = new Field[8];
- Vector v = new Vector();
-
- if(tableNamePattern == null)
- tableNamePattern = "%";
+ Field f[] = new Field[8];
+ Vector v = new Vector();
- f[0] = new Field(connection,"TABLE_CAT",iVarcharOid,32);
- f[1] = new Field(connection,"TABLE_SCHEM",iVarcharOid,32);
- f[2] = new Field(connection,"TABLE_NAME",iVarcharOid,32);
- f[3] = new Field(connection,"COLUMN_NAME",iVarcharOid,32);
- f[4] = new Field(connection,"GRANTOR",iVarcharOid,32);
- f[5] = new Field(connection,"GRANTEE",iVarcharOid,32);
- f[6] = new Field(connection,"PRIVILEGE",iVarcharOid,32);
- f[7] = new Field(connection,"IS_GRANTABLE",iVarcharOid,32);
+ if (tableNamePattern == null)
+ tableNamePattern = "%";
- // This is taken direct from the psql source
- java.sql.ResultSet r = connection.ExecSQL("SELECT relname, relacl FROM pg_class, pg_user WHERE ( relkind = 'r' OR relkind = 'i') and relname !~ '^pg_' and relname !~ '^xin[vx][0-9]+' and usesysid = relowner and relname like '"+tableNamePattern.toLowerCase()+"' ORDER BY relname");
- while(r.next()) {
- byte[][] tuple = new byte[8][0];
- tuple[0] = tuple[1]= "".getBytes();
- DriverManager.println("relname=\""+r.getString(1)+"\" relacl=\""+r.getString(2)+"\"");
+ f[0] = new Field(connection,"TABLE_CAT",iVarcharOid,32);
+ f[1] = new Field(connection,"TABLE_SCHEM",iVarcharOid,32);
+ f[2] = new Field(connection,"TABLE_NAME",iVarcharOid,32);
+ f[3] = new Field(connection,"COLUMN_NAME",iVarcharOid,32);
+ f[4] = new Field(connection,"GRANTOR",iVarcharOid,32);
+ f[5] = new Field(connection,"GRANTEE",iVarcharOid,32);
+ f[6] = new Field(connection,"PRIVILEGE",iVarcharOid,32);
+ f[7] = new Field(connection,"IS_GRANTABLE",iVarcharOid,32);
- // For now, don't add to the result as relacl needs to be processed.
- //v.addElement(tuple);
- }
+ // This is taken direct from the psql source
+ java.sql.ResultSet r = connection.ExecSQL("SELECT relname, relacl FROM pg_class, pg_user WHERE ( relkind = 'r' OR relkind = 'i') and relname !~ '^pg_' and relname !~ '^xin[vx][0-9]+' and usesysid = relowner and relname like '"+tableNamePattern.toLowerCase()+"' ORDER BY relname");
+ while (r.next()) {
+ byte[][] tuple = new byte[8][0];
+ tuple[0] = tuple[1]= "".getBytes();
+ DriverManager.println("relname=\""+r.getString(1)+"\" relacl=\""+r.getString(2)+"\"");
+
+ // For now, don't add to the result as relacl needs to be processed.
+ //v.addElement(tuple);
+ }
- return new ResultSet(connection,f,v,"OK",1);
+ return new ResultSet(connection,f,v,"OK",1);
}
- /**
+ /*
* Get a description of a table's optimal set of columns that
* uniquely identifies a row. They are ordered by SCOPE.
*
return new ResultSet(connection, f, v, "OK", 1);
}
- /**
+ /*
* Get a description of a table's columns that are automatically
* updated when any value in a row is updated. They are
* unordered.
throw org.postgresql.Driver.notImplemented();
}
- /**
+ /*
* Get a description of a table's primary key columns. They
* are ordered by COLUMN_NAME.
*
);
}
- private java.sql.ResultSet getImportedExportedKeys(String catalog, String schema, String primaryTable, String foreignTable) throws SQLException
- {
- Field f[]=new Field[14];
-
- f[0]=new Field(connection, "PKTABLE_CAT", iVarcharOid, 32);
- f[1]=new Field(connection, "PKTABLE_SCHEM", iVarcharOid, 32);
- f[2]=new Field(connection, "PKTABLE_NAME", iVarcharOid, 32);
- f[3]=new Field(connection, "PKCOLUMN_NAME", iVarcharOid, 32);
- f[4]=new Field(connection, "FKTABLE_CAT", iVarcharOid, 32);
- f[5]=new Field(connection, "FKTABLE_SCHEM", iVarcharOid, 32);
- f[6]=new Field(connection, "FKTABLE_NAME", iVarcharOid, 32);
- f[7]=new Field(connection, "FKCOLUMN_NAME", iVarcharOid, 32);
- f[8]=new Field(connection, "KEY_SEQ", iInt2Oid, 2);
- f[9]=new Field(connection, "UPDATE_RULE", iInt2Oid, 2);
- f[10]=new Field(connection, "DELETE_RULE", iInt2Oid, 2);
- f[11]=new Field(connection, "FK_NAME", iVarcharOid, 32);
- f[12]=new Field(connection, "PK_NAME", iVarcharOid, 32);
- f[13]=new Field(connection, "DEFERRABILITY", iInt2Oid, 2);
-
- java.sql.ResultSet rs = connection.ExecSQL("SELECT c.relname,c2.relname,"
- + "t.tgconstrname,ic.relname,"
- + "t.tgdeferrable,t.tginitdeferred,"
- + "t.tgnargs,t.tgargs,p.proname "
- + "FROM pg_trigger t,pg_class c,pg_class c2,"
- + "pg_class ic,pg_proc p, pg_index i "
- + "WHERE t.tgrelid=c.oid AND t.tgconstrrelid=c2.oid "
- + "AND t.tgfoid=p.oid AND tgisconstraint "
- + ((primaryTable!=null) ? "AND c2.relname='"+primaryTable+"' " : "")
- + ((foreignTable!=null) ? "AND c.relname='"+foreignTable+"' " : "")
- + "AND i.indrelid=c.oid "
- + "AND i.indexrelid=ic.oid AND i.indisprimary "
- + "ORDER BY c.relname,c2.relname"
- );
- Vector tuples = new Vector();
- short seq=0;
- if(rs.next()) {
+ private java.sql.ResultSet getImportedExportedKeys(String catalog, String schema, String primaryTable, String foreignTable) throws SQLException
+ {
+ Field f[]=new Field[14];
+
+ f[0]=new Field(connection, "PKTABLE_CAT", iVarcharOid, 32);
+ f[1]=new Field(connection, "PKTABLE_SCHEM", iVarcharOid, 32);
+ f[2]=new Field(connection, "PKTABLE_NAME", iVarcharOid, 32);
+ f[3]=new Field(connection, "PKCOLUMN_NAME", iVarcharOid, 32);
+ f[4]=new Field(connection, "FKTABLE_CAT", iVarcharOid, 32);
+ f[5]=new Field(connection, "FKTABLE_SCHEM", iVarcharOid, 32);
+ f[6]=new Field(connection, "FKTABLE_NAME", iVarcharOid, 32);
+ f[7]=new Field(connection, "FKCOLUMN_NAME", iVarcharOid, 32);
+ f[8]=new Field(connection, "KEY_SEQ", iInt2Oid, 2);
+ f[9]=new Field(connection, "UPDATE_RULE", iInt2Oid, 2);
+ f[10]=new Field(connection, "DELETE_RULE", iInt2Oid, 2);
+ f[11]=new Field(connection, "FK_NAME", iVarcharOid, 32);
+ f[12]=new Field(connection, "PK_NAME", iVarcharOid, 32);
+ f[13]=new Field(connection, "DEFERRABILITY", iInt2Oid, 2);
+
+ java.sql.ResultSet rs = connection.ExecSQL("SELECT c.relname,c2.relname,"
+ + "t.tgconstrname,ic.relname,"
+ + "t.tgdeferrable,t.tginitdeferred,"
+ + "t.tgnargs,t.tgargs,p.proname "
+ + "FROM pg_trigger t,pg_class c,pg_class c2,"
+ + "pg_class ic,pg_proc p, pg_index i "
+ + "WHERE t.tgrelid=c.oid AND t.tgconstrrelid=c2.oid "
+ + "AND t.tgfoid=p.oid AND tgisconstraint "
+ + ((primaryTable!=null) ? "AND c2.relname='"+primaryTable+"' " : "")
+ + ((foreignTable!=null) ? "AND c.relname='"+foreignTable+"' " : "")
+ + "AND i.indrelid=c.oid "
+ + "AND i.indexrelid=ic.oid AND i.indisprimary "
+ + "ORDER BY c.relname,c2.relname"
+ );
+ Vector tuples = new Vector();
+ short seq=0;
+ if (rs.next()) {
boolean hasMore;
do {
- byte tuple[][]=new byte[14][0];
- for (int k = 0;k < 14;k++)
+ byte tuple[][]=new byte[14][0];
+ for (int k = 0;k < 14;k++)
tuple[k] = null;
- String fKeyName=rs.getString(3);
- boolean foundRule=false;
- do {
+ String fKeyName=rs.getString(3);
+ boolean foundRule=false;
+ do {
String proname=rs.getString(9);
- if(proname!=null && proname.startsWith("RI_FKey_")) {
- int col=-1;
- if(proname.endsWith("_upd")) col=9; // UPDATE_RULE
- else if(proname.endsWith("_del")) col=10; // DELETE_RULE
- if(col>-1) {
+ if (proname!=null && proname.startsWith("RI_FKey_")) {
+ int col=-1;
+ if (proname.endsWith("_upd")) col=9; // UPDATE_RULE
+ else if (proname.endsWith("_del")) col=10; // DELETE_RULE
+ if (col>-1) {
String rule=proname.substring(8, proname.length()-4);
int action=importedKeyNoAction;
- if("cascade".equals(rule)) action=importedKeyCascade;
- else if("setnull".equals(rule)) action=importedKeySetNull;
- else if("setdefault".equals(rule)) action=importedKeySetDefault;
+ if ("cascade".equals(rule)) action=importedKeyCascade;
+ else if ("setnull".equals(rule)) action=importedKeySetNull;
+ else if ("setdefault".equals(rule)) action=importedKeySetDefault;
tuple[col]=Integer.toString(action).getBytes();
foundRule=true;
- }
+ }
}
- } while((hasMore=rs.next()) && fKeyName.equals(rs.getString(3)));
+ } while ((hasMore=rs.next()) && fKeyName.equals(rs.getString(3)));
- if(foundRule) {
+ if (foundRule) {
tuple[2]=rs.getBytes(2); //PKTABLE_NAME
tuple[6]=rs.getBytes(1); //FKTABLE_NAME
String s=rs.getString(8);
int pos=s.lastIndexOf("\\000");
for(int c=0;c<numColumns;c++) {
- if(pos>-1) {
+ if (pos>-1) {
int pos2=s.lastIndexOf("\\000", pos-1);
- if(pos2>-1) {
- if(fkeyColumns.length()>0) fkeyColumns.insert(0, ',');
- fkeyColumns.insert(0, s.substring(pos2+4, pos)); //FKCOLUMN_NAME
- pos=s.lastIndexOf("\\000", pos2-1);
- if(pos>-1) {
- if(pkeyColumns.length()>0) pkeyColumns.insert(0, ',');
+ if (pos2>-1) {
+ if (fkeyColumns.length()>0) fkeyColumns.insert(0, ',');
+ fkeyColumns.insert(0, s.substring(pos2+4, pos)); //FKCOLUMN_NAME
+ pos=s.lastIndexOf("\\000", pos2-1);
+ if (pos>-1) {
+ if (pkeyColumns.length()>0) pkeyColumns.insert(0, ',');
pkeyColumns.insert(0, s.substring(pos+4, pos2)); //PKCOLUMN_NAME
- }
+ }
+ }
}
- }
}
tuple[7]=fkeyColumns.toString().getBytes(); //FKCOLUMN_NAME
tuple[3]=pkeyColumns.toString().getBytes(); //PKCOLUMN_NAME
int deferrability=importedKeyNotDeferrable;
boolean deferrable=rs.getBoolean(5);
boolean initiallyDeferred=rs.getBoolean(6);
- if(deferrable) {
- if(initiallyDeferred)
+ if (deferrable) {
+ if (initiallyDeferred)
deferrability=importedKeyInitiallyDeferred;
- else
+ else
deferrability=importedKeyInitiallyImmediate;
}
tuple[13]=Integer.toString(deferrability).getBytes();
tuples.addElement(tuple);
- }
- } while(hasMore);
- }
+ }
+ } while (hasMore);
+ }
- return new ResultSet(connection, f, tuples, "OK", 1);
+ return new ResultSet(connection, f, tuples, "OK", 1);
}
- /**
+ /*
* Get a description of the primary key columns that are
* referenced by a table's foreign key columns (the primary keys
* imported by a table). They are ordered by PKTABLE_CAT,
public java.sql.ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException
{
return getImportedExportedKeys(catalog, schema, null, table);
- }
+ }
- /**
+ /*
* Get a description of a foreign key columns that reference a
* table's primary key columns (the foreign keys exported by a
* table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM,
return getImportedExportedKeys(catalog, schema, table, null);
}
- /**
+ /*
* Get a description of the foreign key columns in the foreign key
* table that reference the primary key columns of the primary key
* table (describe how one table imports another's key.) This
return getImportedExportedKeys(primaryCatalog, primarySchema, primaryTable, foreignTable);
}
- /**
+ /*
* Get a description of all the standard SQL types supported by
* this database. They are ordered by DATA_TYPE and then by how
* closely the data type maps to the corresponding JDBC SQL type.
throw new PSQLException("postgresql.metadata.unavailable");
}
- /**
+ /*
* Get a description of a table's indices and statistics. They are
* ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION.
*
tuple[0] = "".getBytes();
tuple[1] = "".getBytes();
tuple[2] = r.getBytes(1);
- tuple[3] = r.getBoolean(2) ? "false".getBytes() : "true".getBytes();
- tuple[4] = null;
+ tuple[3] = r.getBoolean(2) ? "false".getBytes() : "true".getBytes();
+ tuple[4] = null;
tuple[5] = r.getBytes(3);
tuple[6] = r.getBoolean(4) ?
Integer.toString(tableIndexClustered).getBytes() :
Integer.toString(tableIndexOther).getBytes();
tuple[7] = Integer.toString(i + 1).getBytes();
java.sql.ResultSet columnNameRS = connection.ExecSQL("select a.attname FROM pg_attribute a WHERE (a.attnum = " + columnOrdinals[i] + ") AND (a.attrelid = " + r.getInt(9) + ")");
- if(columnNameRS.next())
- tuple[8] = columnNameRS.getBytes(1);
- else
- tuple[8] = "".getBytes();
+ if (columnNameRS.next())
+ tuple[8] = columnNameRS.getBytes(1);
+ else
+ tuple[8] = "".getBytes();
tuple[8] = columnNameRS.getBytes(1);
tuple[9] = null; // sort sequence ???
tuple[10] = r.getBytes(7); // inexact
// ** JDBC 2 Extensions **
- /**
+ /*
* Does the database support the given result set type?
*
* @param type - defined in java.sql.ResultSet
}
- /**
+ /*
* Does the database support the concurrency type in combination
* with the given result set type?
*
return false;
}
- /**
+ /*
* Indicates whether the driver supports batch updates.
*/
public boolean supportsBatchUpdates() throws SQLException
return true;
}
- /**
+ /*
* Return user defined types in a schema
*/
public java.sql.ResultSet getUDTs(String catalog,
}
- /**
+ /*
* Retrieves the connection that produced this metadata object.
*
* @return the connection that produced this metadata object
import org.postgresql.util.*;
import java.sql.*;
-/**
+/*
* This class extends java.sql.BatchUpdateException, and provides our
* internationalisation handling.
*/
import org.postgresql.largeobject.*;
import org.postgresql.util.*;
-/**
+/*
* A SQL Statement is pre-compiled and stored in a PreparedStatement object.
* This object can then be used to efficiently execute this statement multiple
* times.
private static ThreadLocal tl_df = new ThreadLocal(); // setDate() SimpleDateFormat
private static ThreadLocal tl_tsdf = new ThreadLocal(); // setTimestamp() SimpleDateFormat
- /**
+ /*
* Constructor for the PreparedStatement class.
* Split the SQL statement into segments - separated by the arguments.
* When we rebuild the thing with the arguments, we can substitute the
templateStrings[i] = (String)v.elementAt(i);
}
- /**
+ /*
* A Prepared SQL query is executed and its ResultSet is returned
*
* @return a ResultSet that contains the data produced by the
return super.executeQuery(compileQuery()); // in Statement class
}
- /**
+ /*
* Execute a SQL INSERT, UPDATE or DELETE statement. In addition,
* SQL statements that return nothing such as SQL DDL statements can
* be executed.
return super.executeUpdate(compileQuery()); // in Statement class
}
- /**
+ /*
* Helper - this compiles the SQL query from the various parameters
* This is identical to toString() except it throws an exception if a
* parameter is unused.
return sbuf.toString();
}
- /**
+ /*
* Set a parameter to SQL NULL
*
* <p><B>Note:</B> You must specify the parameters SQL type (although
set(parameterIndex, "null");
}
- /**
+ /*
* Set a parameter to a Java boolean value. The driver converts this
* to a SQL BIT value when it sends it to the database.
*
set(parameterIndex, x ? "'t'" : "'f'");
}
- /**
+ /*
* Set a parameter to a Java byte value. The driver converts this to
* a SQL TINYINT value when it sends it to the database.
*
set(parameterIndex, Integer.toString(x));
}
- /**
+ /*
* Set a parameter to a Java short value. The driver converts this
* to a SQL SMALLINT value when it sends it to the database.
*
set(parameterIndex, Integer.toString(x));
}
- /**
+ /*
* Set a parameter to a Java int value. The driver converts this to
* a SQL INTEGER value when it sends it to the database.
*
set(parameterIndex, Integer.toString(x));
}
- /**
+ /*
* Set a parameter to a Java long value. The driver converts this to
* a SQL BIGINT value when it sends it to the database.
*
set(parameterIndex, Long.toString(x));
}
- /**
+ /*
* Set a parameter to a Java float value. The driver converts this
* to a SQL FLOAT value when it sends it to the database.
*
set(parameterIndex, Float.toString(x));
}
- /**
+ /*
* Set a parameter to a Java double value. The driver converts this
* to a SQL DOUBLE value when it sends it to the database
*
set(parameterIndex, Double.toString(x));
}
- /**
+ /*
* Set a parameter to a java.lang.BigDecimal value. The driver
* converts this to a SQL NUMERIC value when it sends it to the
* database.
set(parameterIndex, x.toString());
}
- /**
+ /*
* Set a parameter to a Java String value. The driver converts this
* to a SQL VARCHAR or LONGVARCHAR value (depending on the arguments
* size relative to the driver's limits on VARCHARs) when it sends it
}
}
- /**
+ /*
* Set a parameter to a Java array of bytes. The driver converts this
* to a SQL VARBINARY or LONGVARBINARY (depending on the argument's
* size relative to the driver's limits on VARBINARYs) when it sends
}
}
- /**
+ /*
* Set a parameter to a java.sql.Date value. The driver converts this
* to a SQL DATE value when it sends it to the database.
*
//set(parameterIndex, df.format(new java.util.Date(x.getTime()+86400000)));
}
- /**
+ /*
* Set a parameter to a java.sql.Time value. The driver converts
* this to a SQL TIME value when it sends it to the database.
*
}
}
- /**
+ /*
* Set a parameter to a java.sql.Timestamp value. The driver converts
* this to a SQL TIMESTAMP value when it sends it to the database.
*
}
}
- /**
+ /*
* When a very large ASCII value is input to a LONGVARCHAR parameter,
* it may be more practical to send it via a java.io.InputStream.
* JDBC will read the data from the stream as needed, until it reaches
}
}
- /**
+ /*
* When a very large Unicode value is input to a LONGVARCHAR parameter,
* it may be more practical to send it via a java.io.InputStream.
* JDBC will read the data from the stream as needed, until it reaches
}
}
- /**
+ /*
* When a very large binary value is input to a LONGVARBINARY parameter,
* it may be more practical to send it via a java.io.InputStream.
* JDBC will read the data from the stream as needed, until it reaches
}
}
- /**
+ /*
* In general, parameter values remain in force for repeated used of a
* Statement. Setting a parameter value automatically clears its
* previous value. However, in coms cases, it is useful to immediately
inStrings[i] = null;
}
- /**
+ /*
* Set the value of a parameter using an object; use the java.lang
* equivalent objects for integral values.
*
setObject(parameterIndex, x, targetSqlType, 0);
}
- /**
+ /*
* This stores an Object into a parameter.
* <p>New for 6.4, if the object is not recognised, but it is
* Serializable, then the object is serialised using the
setSerialize(parameterIndex, connection.putObject(x), x.getClass().getName() );
}
- /**
+ /*
* Some prepared statements return multiple results; the execute method
* handles these complex statements as well as the simpler form of
* statements handled by executeQuery and executeUpdate
return super.execute(compileQuery()); // in Statement class
}
- /**
+ /*
* Returns the SQL statement with the current template values
* substituted.
* NB: This is identical to compileQuery() except instead of throwing
// END OF PUBLIC INTERFACE
// **************************************************************
- /**
+ /*
* There are a lot of setXXX classes which all basically do
* the same thing. We need a method which actually does the
* set for us.
inStrings[paramIndex - 1] = s;
}
- /**
+ /*
* Set a parameter to a tablerow-type oid reference.
*
* @param parameterIndex the first parameter is 1...
// ** JDBC 2 Extensions **
- /**
+ /*
* This parses the query and adds it to the current batch
*/
public void addBatch() throws SQLException
super.addBatch(compileQuery());
}
- /**
+ /*
* Not sure what this one does, so I'm saying this returns the MetaData for
* the last ResultSet returned!
*/
setString(i, x.toString());
}
- /**
+ /*
* Sets a Blob
*/
public void setBlob(int i, Blob x) throws SQLException
setInt(i, oid);
}
- /**
+ /*
* This is similar to setBinaryStream except it uses a Reader instead of
* InputStream.
*/
}
}
- /**
+ /*
* New in 7.1
*/
public void setClob(int i, Clob x) throws SQLException
setInt(i, oid);
}
- /**
+ /*
* At least this works as in PostgreSQL null represents anything null ;-)
*
* New in 7,1
throw org.postgresql.Driver.notImplemented();
}
- /**
+ /*
* New in 7,1
*/
public void setDate(int i, java.sql.Date d, java.util.Calendar cal) throws SQLException
}
}
- /**
+ /*
* New in 7,1
*/
public void setTime(int i, Time t, java.util.Calendar cal) throws SQLException
}
}
- /**
+ /*
* New in 7,1
*/
public void setTimestamp(int i, Timestamp t, java.util.Calendar cal) throws SQLException
import org.postgresql.util.*;
import org.postgresql.core.Encoding;
-/**
+/*
* A ResultSet provides access to a table of data generated by executing a
* Statement. The table rows are retrieved in sequence. Within a row its
* column values can be accessed in any order.
private StringBuffer sbuf = null;
- /**
+ /*
* Create a new ResultSet - Note that we create ResultSets to
* represent the results of everything.
*
super(conn, fields, tuples, status, updateCount, insertOID, binaryCursor);
}
- /**
+ /*
* Create a new ResultSet - Note that we create ResultSets to
* represent the results of everything.
*
super(conn, fields, tuples, status, updateCount, 0, false);
}
- /**
+ /*
* A ResultSet is initially positioned before its first row,
* the first call to next makes the first row the current row;
* the second call makes the second row the current row, etc.
return true;
}
- /**
+ /*
* In some cases, it is desirable to immediately release a ResultSet
* database and JDBC resources instead of waiting for this to happen
* when it is automatically closed. The close method provides this
}
}
- /**
+ /*
* A column may have the value of SQL NULL; wasNull() reports whether
* the last column read had this special value. Note that you must
* first call getXXX on a column to try to read its value and then
return wasNullFlag;
}
- /**
+ /*
* Get the value of a column in the current row as a Java String
*
* @param columnIndex the first column is 1, the second is 2...
return encoding.decode(this_row[columnIndex - 1]);
}
- /**
+ /*
* Get the value of a column in the current row as a Java boolean
*
* @param columnIndex the first column is 1, the second is 2...
return toBoolean( getString(columnIndex) );
}
- /**
+ /*
* Get the value of a column in the current row as a Java byte.
*
* @param columnIndex the first column is 1, the second is 2,...
return 0; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a Java short.
*
* @param columnIndex the first column is 1, the second is 2,...
return 0; // SQL NULL
}
- /**
+ /*
* Get the value of a column in the current row as a Java int.
*
* @param columnIndex the first column is 1, the second is 2,...
return toInt( getFixedString(columnIndex) );
}
- /**
+ /*
* Get the value of a column in the current row as a Java long.
*
* @param columnIndex the first column is 1, the second is 2,...
return toLong( getFixedString(columnIndex) );
}
- /**
+ /*
* Get the value of a column in the current row as a Java float.
*
* @param columnIndex the first column is 1, the second is 2,...
return toFloat( getFixedString(columnIndex) );
}
- /**
+ /*
* Get the value of a column in the current row as a Java double.
*
* @param columnIndex the first column is 1, the second is 2,...
return toDouble( getFixedString(columnIndex) );
}
- /**
+ /*
* Get the value of a column in the current row as a
* java.math.BigDecimal object
*
return toBigDecimal( getFixedString(columnIndex), scale );
}
- /**
+ /*
* Get the value of a column in the current row as a Java byte array.
*
* <p>In normal use, the bytes represent the raw values returned by the
return null;
}
- /**
+ /*
* Get the value of a column in the current row as a java.sql.Date
* object
*
return toDate( getString(columnIndex) );
}
- /**
+ /*
* Get the value of a column in the current row as a java.sql.Time
* object
*
return toTime( getString(columnIndex) );
}
- /**
+ /*
* Get the value of a column in the current row as a
* java.sql.Timestamp object
*
return toTimestamp( getString(columnIndex), this );
}
- /**
+ /*
* A column value can be retrieved as a stream of ASCII characters
* and then read in chunks from the stream. This method is
* particular suitable for retrieving large LONGVARCHAR values.
}
}
- /**
+ /*
* A column value can also be retrieved as a stream of Unicode
* characters. We implement this as a binary stream.
*
}
}
- /**
+ /*
* A column value can also be retrieved as a binary strea. This
* method is suitable for retrieving LONGVARBINARY values.
*
return null;
}
- /**
+ /*
* The following routines simply convert the columnName into
* a columnIndex and then call the appropriate routine above.
*
return getDouble(findColumn(columnName));
}
- /**
+ /*
* @deprecated
*/
public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException
return getAsciiStream(findColumn(columnName));
}
- /**
+ /*
*
* ** DEPRECATED IN JDBC 2 **
*
return getBinaryStream(findColumn(columnName));
}
- /**
+ /*
* The first warning reported by calls on this ResultSet is
* returned. Subsequent ResultSet warnings will be chained
* to this SQLWarning.
return warnings;
}
- /**
+ /*
* After this call, getWarnings returns null until a new warning
* is reported for this ResultSet
*
warnings = null;
}
- /**
+ /*
* Get the name of the SQL cursor used by this ResultSet
*
* <p>In SQL, a result table is retrieved though a cursor that is
return connection.getCursorName();
}
- /**
+ /*
* The numbers, types and properties of a ResultSet's columns are
* provided by the getMetaData method
*
return new ResultSetMetaData(rows, fields);
}
- /**
+ /*
* Get the value of a column in the current row as a Java object
*
* <p>This method will return the value of the given column as a
}
}
- /**
+ /*
* Get the value of a column in the current row as a Java object
*
*<p> This method will return the value of the given column as a
return getObject(findColumn(columnName));
}
- /**
+ /*
* Map a ResultSet column name to a ResultSet column index
*
* @param columnName the name of the column
}
}
- /**
+ /*
* New in 7.1
*/
public Clob getClob(String columnName) throws SQLException
return getClob(findColumn(columnName));
}
- /**
+ /*
* New in 7.1
*/
public Clob getClob(int i) throws SQLException
return getObject(findColumn(columnName), map);
}
- /**
+ /*
* This checks against map for the type of column i, and if found returns
* an object based on that mapping. The class must implement the SQLData
* interface.
String t = getTypeName(i);
SQLData o = (SQLData) map.get(t);
// If the type is not in the map, then pass to the existing code
- if(o==null)
+ if (o==null)
return getObject(i);
o.readSQL(s,t);
return o;
throw new PSQLException("postgresql.noupdate");
}
- /**
+ /*
* This is called by Statement to register itself with this statement.
* It's used currently by getStatement() but may also with the new core
* package.
import org.postgresql.*;
import org.postgresql.util.*;
-/**
+/*
* A ResultSetMetaData object can be used to find out about the types and
* properties of the columns in a ResultSet
*
Vector rows;
Field[] fields;
- /**
+ /*
* Initialise for a result with a tuple set and
* a field descriptor set
*
this.fields = fields;
}
- /**
+ /*
* Whats the number of columns in the ResultSet?
*
* @return the number
return fields.length;
}
- /**
+ /*
* Is the column automatically numbered (and thus read-only)
* I believe that PostgreSQL does not support this feature.
*
return false;
}
- /**
+ /*
* Does a column's case matter? ASSUMPTION: Any field that is
* not obviously case insensitive is assumed to be case sensitive
*
}
}
- /**
+ /*
* Can the column be used in a WHERE clause? Basically for
* this, I split the functions into two types: recognised
* types (which are always useable), and OTHER types (which
}
}
- /**
+ /*
* Is the column a cash value? 6.1 introduced the cash/money
* type, which haven't been incorporated as of 970414, so I
* just check the type name for both 'cash' and 'money'
return type_name.equals("cash") || type_name.equals("money");
}
- /**
+ /*
* Indicates the nullability of values in the designated column.
*
* @param column the first column is 1, the second is 2...
return columnNullableUnknown;
}
- /**
+ /*
* Is the column a signed number? In PostgreSQL, all numbers
* are signed, so this is trivial. However, strings are not
* signed (duh!)
}
}
- /**
+ /*
* What is the column's normal maximum width in characters?
*
* @param column the first column is 1, the second is 2, etc.
return f.getLength();
}
- /**
+ /*
* What is the suggested column title for use in printouts and
* displays? We suggest the ColumnName!
*
return getColumnName(column);
}
- /**
+ /*
* What's a column's name?
*
* @param column the first column is 1, the second is 2, etc.
return "field" + column;
}
- /**
+ /*
* What is a column's table's schema? This relies on us knowing
* the table name....which I don't know how to do as yet. The
* JDBC specification allows us to return "" if this is not
return "";
}
- /**
+ /*
* What is a column's number of decimal digits.
*
* @param column the first column is 1, the second is 2...
}
}
- /**
+ /*
* What is a column's number of digits to the right of the
* decimal point?
*
}
}
- /**
+ /*
* Whats a column's table's name? How do I find this out? Both
* getSchemaName() and getCatalogName() rely on knowing the table
* Name, so we need this before we can work on them.
return "";
}
- /**
+ /*
* What's a column's table's catalog name? As with getSchemaName(),
* we can say that if getTableName() returns n/a, then we can too -
* otherwise, we need to work on it.
return "";
}
- /**
+ /*
* What is a column's SQL Type? (java.sql.Type int)
*
* @param column the first column is 1, the second is 2, etc.
return getField(column).getSQLType();
}
- /**
+ /*
* Whats is the column's data source specific type name?
*
* @param column the first column is 1, the second is 2, etc.
return getField(column).getPGType();
}
- /**
+ /*
* Is the column definitely not writable? In reality, we would
* have to check the GRANT/REVOKE stuff for this to be effective,
* and I haven't really looked into that yet, so this will get
return false;
}
- /**
+ /*
* Is it possible for a write on the column to succeed? Again, we
* would in reality have to check the GRANT/REVOKE stuff, which
* I haven't worked with as yet. However, if it isn't ReadOnly, then
return !isReadOnly(column);
}
- /**
+ /*
* Will a write on this column definately succeed? Hmmm...this
* is a bad one, since the two preceding functions have not been
* really defined. I cannot tell is the short answer. I thus
// END OF PUBLIC INTERFACE
// ********************************************************
- /**
+ /*
* For several routines in this package, we need to convert
* a columnIndex into a Field[] descriptor. Rather than do
* the same code several times, here it is.
import java.util.Vector;
import org.postgresql.util.*;
-/**
+/*
* A Statement object is used for executing a static SQL statement and
* obtaining the results produced by it.
*
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
* that created us.
*
concurrency = java.sql.ResultSet.CONCUR_READ_ONLY;
}
- /**
+ /*
* Execute a SQL statement that retruns a single ResultSet
*
* @param sql typically a static SQL SELECT statement
return result;
}
- /**
+ /*
* Execute a SQL INSERT, UPDATE or DELETE statement. In addition
* SQL statements that return nothing such as SQL DDL statements
* can be executed
return this.getUpdateCount();
}
- /**
+ /*
* 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
connection.setCursorName(name);
}
- /**
+ /*
* Execute a SQL statement that may return multiple results. We
* don't have to worry about this since we do not support multiple
* ResultSets. You can use getResultSet or getUpdateCount to
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.
return ((org.postgresql.ResultSet)result).getResultCount();
}
- /**
+ /*
* getMoreResults moves to a Statement's next result. If it returns
* true, this result is a ResulSet.
*
throw org.postgresql.Driver.notImplemented();
}
- /**
+ /*
* New in 7.1
*/
public void setResultSetConcurrency(int value) throws SQLException
concurrency = value;
}
- /**
+ /*
* New in 7.1
*/
public void setResultSetType(int value) throws SQLException
import org.postgresql.largeobject.*;
import org.postgresql.util.*;
-/**
+/*
* @see ResultSet
* @see ResultSetMetaData
* @see java.sql.ResultSet
public class UpdateableResultSet extends org.postgresql.jdbc2.ResultSet
{
- /**
+ /*
* Create a new ResultSet - Note that we create ResultSets to
* represent the results of everything.
*
super(conn, fields, tuples, status, updateCount, insertOID, binaryCursor);
}
- /**
+ /*
* Create a new ResultSet - Note that we create ResultSets to
* represent the results of everything.
*
import java.io.IOException;
import java.sql.SQLException;
-/**
+/*
* This is an initial implementation of an InputStream from a large object.
* For now, the bare minimum is implemented. Later (after 7.1) we will overide
* the other read methods to optimise them.
*/
public class BlobInputStream extends InputStream
{
- /**
+ /*
* The parent LargeObject
*/
private LargeObject lo;
- /**
+ /*
* Buffer used to improve performance
*/
private byte[] buffer;
- /**
+ /*
* Position within buffer
*/
private int bpos;
- /**
+ /*
* The buffer size
*/
private int bsize;
- /**
+ /*
* The mark position
*/
private int mpos = 0;
- /**
+ /*
* @param lo LargeObject to read from
*/
public BlobInputStream(LargeObject lo)
this(lo, 1024);
}
- /**
+ /*
* @param lo LargeObject to read from
* @param bsize buffer size
*/
this.bsize = bsize;
}
- /**
+ /*
* The minimum required to implement input stream
*/
public int read() throws java.io.IOException
}
- /**
+ /*
* Closes this input stream and releases any system resources associated
* with the stream.
*
}
}
- /**
+ /*
* Marks the current position in this input stream. A subsequent call to
* the <code>reset</code> method repositions this stream at the last marked
* position so that subsequent reads re-read the same bytes.
}
}
- /**
+ /*
* Repositions this stream to the position at the time the
* <code>mark</code> method was last called on this input stream.
* NB: If mark is not called we move to the begining.
}
}
- /**
+ /*
* Tests if this input stream supports the <code>mark</code> and
* <code>reset</code> methods. The <code>markSupported</code> method of
* <code>InputStream</code> returns <code>false</code>.
import java.io.OutputStream;
import java.sql.SQLException;
-/**
+/*
* This implements a basic output stream that writes to a LargeObject
*/
public class BlobOutputStream extends OutputStream
{
- /**
+ /*
* The parent LargeObject
*/
private LargeObject lo;
- /**
+ /*
* Buffer
*/
private byte buf[];
- /**
+ /*
* Size of the buffer (default 1K)
*/
private int bsize;
- /**
+ /*
* Position within the buffer
*/
private int bpos;
- /**
+ /*
* Create an OutputStream to a large object
* @param lo LargeObject
*/
this(lo, 1024);
}
- /**
+ /*
* Create an OutputStream to a large object
* @param lo LargeObject
* @param bsize The size of the buffer used to improve performance
}
}
- /**
+ /*
* Flushes this output stream and forces any buffered output bytes
* to be written out. The general contract of <code>flush</code> is
* that calling it is an indication that, if any bytes previously
}
}
- /**
+ /*
* Closes this output stream and releases any system resources
* associated with this stream. The general contract of <code>close</code>
* is that it closes the output stream. A closed stream cannot perform
import org.postgresql.fastpath.*;
-/**
+/*
* This class implements the large object interface to org.postgresql.
*
* <p>It provides the basic methods required to run the interface, plus
*/
public class LargeObject
{
- /**
+ /*
* Indicates a seek from the begining of a file
*/
public static final int SEEK_SET = 0;
- /**
+ /*
* Indicates a seek from the current position
*/
public static final int SEEK_CUR = 1;
- /**
+ /*
* Indicates a seek from the end of a file
*/
public static final int SEEK_END = 2;
private boolean closed = false; // true when we are closed
- /**
+ /*
* This opens a large object.
*
* <p>If the object does not exist, then an SQLException is thrown.
close();
}
- /**
+ /*
* @return the OID of this LargeObject
*/
public int getOID()
return oid;
}
- /**
+ /*
* This method closes the object. You must not call methods in this
* object after this is called.
* @exception SQLException if a database-access error occurs.
}
}
- /**
+ /*
* Reads some data from the object, and return as a byte[] array
*
* @param len number of bytes to read
return fp.getData("loread", args);
// This version allows us to break this down into 4k blocks
- //if(len<=4048) {
+ //if (len<=4048) {
//// handle as before, return the whole block in one go
//FastpathArg args[] = new FastpathArg[2];
//args[0] = new FastpathArg(fd);
//// return in 4k blocks
//byte[] buf=new byte[len];
//int off=0;
- //while(len>0) {
+ //while (len>0) {
//int bs=4048;
//len-=bs;
- //if(len<0) {
+ //if (len<0) {
//bs+=len;
//len=0;
//}
//}
}
- /**
+ /*
* Reads some data from the object into an existing array
*
* @param buf destination array
return len;
}
- /**
+ /*
* Writes an array to the object
*
* @param buf array to write
fp.fastpath("lowrite", false, args);
}
- /**
+ /*
* Writes some data from an array to the object
*
* @param buf destination array
write(data);
}
- /**
+ /*
* Sets the current position within the object.
*
* <p>This is similar to the fseek() call in the standard C library. It
fp.fastpath("lo_lseek", false, args);
}
- /**
+ /*
* Sets the current position within the object.
*
* <p>This is similar to the fseek() call in the standard C library. It
seek(pos, SEEK_SET);
}
- /**
+ /*
* @return the current position within the object
* @exception SQLException if a database-access error occurs.
*/
return fp.getInteger("lo_tell", args);
}
- /**
+ /*
* This method is inefficient, as the only way to find out the size of
* the object is to seek to the end, record the current position, then
* return to the original position.
return sz;
}
- /**
+ /*
* Returns an InputStream from this object.
*
* <p>This InputStream can then be used in any method that requires an
return new BlobInputStream(this);
}
- /**
+ /*
* Returns an OutputStream to this object
*
* <p>This OutputStream can then be used in any method that requires an
import org.postgresql.fastpath.*;
import org.postgresql.util.*;
-/**
+/*
* This class implements the large object interface to org.postgresql.
*
* <p>It provides methods that allow client code to create, open and delete
// the fastpath api for this connection
private Fastpath fp;
- /**
+ /*
* This mode indicates we want to write to an object
*/
public static final int WRITE = 0x00020000;
- /**
+ /*
* This mode indicates we want to read an object
*/
public static final int READ = 0x00040000;
- /**
+ /*
* This mode is the default. It indicates we want read and write access to
* a large object
*/
public static final int READWRITE = READ | WRITE;
- /**
+ /*
* This prevents us being created by mere mortals
*/
private LargeObjectManager()
{}
- /**
+ /*
* Constructs the LargeObject API.
*
* <p><b>Important Notice</b>
DriverManager.println("Large Object initialised");
}
- /**
+ /*
* This opens an existing large object, based on its OID. This method
* assumes that READ and WRITE access is required (the default).
*
return new LargeObject(fp, oid, READWRITE);
}
- /**
+ /*
* This opens an existing large object, based on its OID
*
* @param oid of large object
return new LargeObject(fp, oid, mode);
}
- /**
+ /*
* This creates a large object, returning its OID.
*
* <p>It defaults to READWRITE for the new object's attributes.
return fp.getInteger("lo_creat", args);
}
- /**
+ /*
* This creates a large object, returning its OID
*
* @param mode a bitmask describing different attributes of the new object
return fp.getInteger("lo_creat", args);
}
- /**
+ /*
* This deletes a large object.
*
* @param oid describing object to delete
fp.fastpath("lo_unlink", false, args);
}
- /**
+ /*
* This deletes a large object.
*
* <p>It is identical to the delete method, and is supplied as the C API uses
import org.postgresql.largeobject.*;
import org.postgresql.largeobject.*;
-/**
+/*
* This implements the Blob interface, which is basically another way to
* access a LargeObject.
*
- * $Id: PGblob.java,v 1.2 2001/10/25 05:59:59 momjian Exp $
+ * $Id: PGblob.java,v 1.3 2001/11/19 22:33:39 momjian Exp $
*
*/
public class PGblob implements java.sql.Blob
import org.postgresql.largeobject.*;
import org.postgresql.largeobject.*;
-/**
+/*
* This implements the Blob interface, which is basically another way to
* access a LargeObject.
*
- * $Id: PGclob.java,v 1.2 2001/10/25 05:59:59 momjian Exp $
+ * $Id: PGclob.java,v 1.3 2001/11/19 22:33:39 momjian Exp $
*
*/
public class PGclob implements java.sql.Clob
import org.postgresql.test.jdbc2.*;
import java.sql.*;
-/**
+/*
* Executes all known tests for JDBC2 and includes some utility methods.
*/
public class JDBC2Tests extends TestSuite
{
- /**
+ /*
* Returns the Test database JDBC URL
*/
public static String getURL()
return System.getProperty("database");
}
- /**
+ /*
* Returns the Postgresql username
*/
public static String getUser()
return System.getProperty("username");
}
- /**
+ /*
* Returns the user's password
*/
public static String getPassword()
return System.getProperty("password");
}
- /**
+ /*
* Helper - opens a connection.
*/
public static java.sql.Connection openDB()
return null;
}
- /**
+ /*
* Helper - closes an open connection. This rewrites SQLException to a failed
* assertion. It's static so other classes can use it.
*/
}
}
- /**
+ /*
* Helper - creates a test table for use by a test
*/
public static void createTable(Connection con,
}
}
- /**
+ /*
* Helper - drops a table
*/
public static void dropTable(Connection con, String table)
}
}
- /**
+ /*
* Helper - generates INSERT SQL - very simple
*/
public static String insertSQL(String table, String values)
return s + " VALUES (" + values + ")";
}
- /**
+ /*
* Helper - generates SELECT SQL - very simple
*/
public static String selectSQL(String table, String columns)
return s;
}
- /**
+ /*
* Helper to prefix a number with leading zeros - ugly but it works...
* @param v value to prefix
* @param l number of digits (0-10)
return s.substring(s.length() - l);
}
- /**
+ /*
* The main entry point for JUnit
*/
public static TestSuite suite()
import junit.framework.TestCase;
import java.sql.*;
-/**
+/*
* Test case for ...
*/
public class FooTest extends TestCase {
super(name);
}
- /**
+ /*
* This tests the acceptsURL() method with a couple of good and badly formed
* jdbc urls
*/
import java.sql.*;
/* TODO tests that can be added to this test case
- - SQLExceptions chained to a BatchUpdateException
- - test PreparedStatement as thoroughly as Statement
+ * - SQLExceptions chained to a BatchUpdateException
+ * - test PreparedStatement as thoroughly as Statement
*/
-/**
+/*
* Test case for Statement.batchExecute()
*/
public class BatchExecuteTest extends TestCase
pstmt.close();
}
- /**
- */
public void testTransactionalBehaviour() throws Exception
{
Statement stmt = con.createStatement();
import org.postgresql.largeobject.*;
-/**
- * $Id: BlobTest.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: BlobTest.java,v 1.4 2001/11/19 22:33:39 momjian Exp $
*
* Some simple tests based on problems reported by users. Hopefully these will
* help prevent previous problems from re-occuring ;-)
JDBC2Tests.closeDB(con);
}
- /**
+ /*
* Tests one method of uploading a blob to the database
*/
public void testUploadBlob_LOOP()
}
}
- /**
+ /*
* Tests one method of uploading a blob to the database
*/
public void testUploadBlob_NATIVE()
}
}
- /**
+ /*
* Helper - uploads a file into a blob using old style methods. We use this
* because it always works, and we can use it as a base to test the new
* methods.
return oid;
}
- /**
+ /*
* Helper - compares the blobs in a table with a local file. Note this alone
* tests the InputStream methods!
*/
import junit.framework.TestCase;
import java.sql.*;
-/**
+/*
* TestCase to test the internal functionality of org.postgresql.jdbc2.Connection
* and it's superclass.
*
* PS: Do you know how difficult it is to type on a train? ;-)
*
- * $Id: ConnectionTest.java,v 1.6 2001/10/25 05:59:59 momjian Exp $
+ * $Id: ConnectionTest.java,v 1.7 2001/11/19 22:33:39 momjian Exp $
*/
public class ConnectionTest extends TestCase
{
- /**
+ /*
* Constructor
*/
public ConnectionTest(String name)
JDBC2Tests.closeDB(con);
}
- /**
+ /*
* Tests the two forms of createStatement()
*/
public void testCreateStatement()
}
}
- /**
+ /*
* Tests the two forms of prepareStatement()
*/
public void testPrepareStatement()
}
}
- /**
+ /*
* Put the test for createPrepareCall here
*/
public void testPrepareCall()
{}
- /**
+ /*
* Test nativeSQL
*/
public void testNativeSQL()
// For now do nothing as it returns itself
}
- /**
+ /*
* Test autoCommit (both get & set)
*/
public void testTransactions()
}
}
- /**
+ /*
* Simple test to see if isClosed works.
*/
public void testIsClosed()
}
}
- /**
+ /*
* Test the warnings system
*/
public void testWarnings()
}
}
- /**
+ /*
* Transaction Isolation Levels
*/
public void testTransactionIsolation()
}
}
- /**
+ /*
* JDBC2 Type mappings
*/
public void testTypeMaps()
import junit.framework.TestCase;
import java.sql.*;
-/**
+/*
* TestCase to test the internal functionality of org.postgresql.jdbc2.DatabaseMetaData
*
* PS: Do you know how difficult it is to type on a train? ;-)
*
- * $Id: DatabaseMetaDataTest.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+ * $Id: DatabaseMetaDataTest.java,v 1.4 2001/11/19 22:33:39 momjian Exp $
*/
public class DatabaseMetaDataTest extends TestCase
{
- /**
+ /*
* Constructor
*/
public DatabaseMetaDataTest(String name)
super(name);
}
- /**
+ /*
* The spec says this may return null, but we always do!
*/
public void testGetMetaData()
}
}
- /**
+ /*
* Test default capabilities
*/
public void testCapabilities()
import junit.framework.TestCase;
import java.sql.*;
-/**
- * $Id: DateTest.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: DateTest.java,v 1.4 2001/11/19 22:33:39 momjian Exp $
*
* Some simple tests based on problems reported by users. Hopefully these will
* help prevent previous problems from re-occuring ;-)
JDBC2Tests.closeDB(con);
}
- /**
+ /*
* Tests the time methods in ResultSet
*/
public void testGetDate()
}
}
- /**
+ /*
* Tests the time methods in PreparedStatement
*/
public void testSetDate()
}
}
- /**
+ /*
* Helper for the date tests. It tests what should be in the db
*/
private void dateTest() throws SQLException
import junit.framework.TestCase;
import java.sql.*;
-/**
- * $Id: DriverTest.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: DriverTest.java,v 1.4 2001/11/19 22:33:39 momjian Exp $
*
* Tests the dynamically created class org.postgresql.Driver
*
super(name);
}
- /**
+ /*
* This tests the acceptsURL() method with a couple of good and badly formed
* jdbc urls
*/
}
}
- /**
+ /*
* Tests parseURL (internal)
*/
- /**
+ /*
* Tests the connect method by connecting to the test database
*/
public void testConnect()
import org.postgresql.core.Encoding;
import java.io.*;
-/**
+/*
* Tests for the Encoding class.
*
- * $Id: EncodingTest.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+ * $Id: EncodingTest.java,v 1.4 2001/11/19 22:33:39 momjian Exp $
*/
import java.sql.*;
import java.math.BigDecimal;
-/**
- * $Id: JBuilderTest.java,v 1.4 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: JBuilderTest.java,v 1.5 2001/11/19 22:33:39 momjian Exp $
*
* Some simple tests to check that the required components needed for JBuilder
* stay working
JDBC2Tests.closeDB(con);
}
- /**
+ /*
* This tests that Money types work. JDBCExplorer barfs if this fails.
*/
public void testMoney()
import junit.framework.TestCase;
import java.sql.*;
-/**
- * $Id: MiscTest.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: MiscTest.java,v 1.4 2001/11/19 22:33:39 momjian Exp $
*
* Some simple tests based on problems reported by users. Hopefully these will
* help prevent previous problems from re-occuring ;-)
super(name);
}
- /**
+ /*
* Some versions of the driver would return rs as a null?
*
* Sasha <ber0806@iperbole.bologna.it> was having this problem.
import java.io.*;
import java.sql.*;
-/**
+/*
* ResultSet tests.
*/
public class ResultSetTest extends TestCase
import junit.framework.TestCase;
import java.sql.*;
-/**
- * $Id: TimeTest.java,v 1.3 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: TimeTest.java,v 1.4 2001/11/19 22:33:39 momjian Exp $
*
* Some simple tests based on problems reported by users. Hopefully these will
* help prevent previous problems from re-occuring ;-)
JDBC2Tests.closeDB(con);
}
- /**
+ /*
* Tests the time methods in ResultSet
*/
public void testGetTime()
}
}
- /**
+ /*
* Tests the time methods in PreparedStatement
*/
public void testSetTime()
}
}
- /**
+ /*
* Helper for the TimeTests. It tests what should be in the db
*/
private void timeTest() throws SQLException
import junit.framework.TestCase;
import java.sql.*;
-/**
- * $Id: TimestampTest.java,v 1.5 2001/10/25 05:59:59 momjian Exp $
+/*
+ * $Id: TimestampTest.java,v 1.6 2001/11/19 22:33:39 momjian Exp $
*
* This has been the most controversial pair of methods since 6.5 was released!
*
JDBC2Tests.closeDB(con);
}
- /**
+ /*
* Tests the time methods in ResultSet
*/
public void testGetTimestamp()
}
}
- /**
+ /*
* Tests the time methods in PreparedStatement
*/
public void testSetTimestamp()
}
}
- /**
+ /*
* Helper for the TimeTests. It tests what should be in the db
*/
private void timestampTest() throws SQLException
package org.postgresql.util;
-/**
+/*
* MD5-based utility function to obfuscate passwords before network transmission
*
* @author Jeremy Wohl
public class MD5Digest
{
- private MD5Digest() {}
+ private MD5Digest()
+ {}
- /**
- * Encodes user/password/salt information in the following way:
- * MD5(MD5(password + user) + salt)
- *
- * @param user The connecting user.
- * @param password The connecting user's password.
- * @param salt A four-character string sent by the server.
- *
- * @return A 35-byte array, comprising the string "md5", followed by an MD5 digest.
- */
- public static byte[] encode(String user, String password, String salt)
- {
- MessageDigest md;
- byte[] temp_digest, pass_digest;
- byte[] hex_digest = new byte[35];
-
+ /*
+ * Encodes user/password/salt information in the following way:
+ * MD5(MD5(password + user) + salt)
+ *
+ * @param user The connecting user.
+ * @param password The connecting user's password.
+ * @param salt A four-character string sent by the server.
+ *
+ * @return A 35-byte array, comprising the string "md5", followed by an MD5 digest.
+ */
+ public static byte[] encode(String user, String password, String salt)
+ {
+ MessageDigest md;
+ byte[] temp_digest, pass_digest;
+ byte[] hex_digest = new byte[35];
- try {
- md = MessageDigest.getInstance("MD5");
+ try
+ {
+ md = MessageDigest.getInstance("MD5");
- md.update(password.getBytes());
- md.update(user.getBytes());
- temp_digest = md.digest();
+ md.update(password.getBytes());
+ md.update(user.getBytes());
+ temp_digest = md.digest();
- bytesToHex(temp_digest, hex_digest, 0);
- md.update(hex_digest, 0, 32);
- md.update(salt.getBytes());
- pass_digest = md.digest();
+ bytesToHex(temp_digest, hex_digest, 0);
+ md.update(hex_digest, 0, 32);
+ md.update(salt.getBytes());
+ pass_digest = md.digest();
- bytesToHex(pass_digest, hex_digest, 3);
- hex_digest[0] = (byte) 'm'; hex_digest[1] = (byte) 'd'; hex_digest[2] = (byte) '5';
- } catch (Exception e) {
- ; // "MessageDigest failure; " + e
+ bytesToHex(pass_digest, hex_digest, 3);
+ hex_digest[0] = (byte) 'm';
+ hex_digest[1] = (byte) 'd';
+ hex_digest[2] = (byte) '5';
+ }
+ catch (Exception e)
+ {
+ ; // "MessageDigest failure; " + e
+ }
+
+ return hex_digest;
}
- return hex_digest;
- }
+ /*
+ * Turn 16-byte stream into a human-readable 32-byte hex string
+ */
+ private static void bytesToHex(byte[] bytes, byte[] hex, int offset)
+ {
+ final char lookup[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f' };
+
+ int i, c, j, pos = offset;
- /**
- * Turn 16-byte stream into a human-readable 32-byte hex string
- */
- private static void bytesToHex(byte[] bytes, byte[] hex, int offset)
- {
- final char lookup[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
- 'a', 'b', 'c', 'd', 'e', 'f' };
-
- int i, c, j, pos = offset;
-
- for (i = 0; i < 16; i++) {
- c = bytes[i] & 0xFF; j = c >> 4;
- hex[pos++] = (byte) lookup[j];
- j = (c & 0xF);
- hex[pos++] = (byte) lookup[j];
+ for (i = 0; i < 16; i++)
+ {
+ c = bytes[i] & 0xFF;
+ j = c >> 4;
+ hex[pos++] = (byte) lookup[j];
+ j = (c & 0xF);
+ hex[pos++] = (byte) lookup[j];
+ }
}
- }
}
import java.util.*;
import java.text.*;
-/**
+/*
* A singleton class to translate JDBC driver messages in SQLException's.
*/
public class MessageTranslator
import java.sql.*;
-/**
+/*
* Converts to and from the postgresql bytea datatype used by the backend.
*
- * $Id: PGbytea.java,v 1.2 2001/10/25 06:00:00 momjian Exp $
+ * $Id: PGbytea.java,v 1.3 2001/11/19 22:33:39 momjian Exp $
*/
public class PGbytea
{
- /**
+ /*
* Converts a PG bytea string (i.e. the text representation
* of the bytea data type) into a java byte[]
*/
return l_return;
}
- /**
+ /*
* Converts a java byte[] into a PG bytea string (i.e. the text
* representation of the bytea data type)
*/
import java.io.*;
import java.sql.*;
-/**
+/*
* This implements a class that handles the PostgreSQL money and cash types
*/
public class PGmoney extends PGobject implements Serializable, Cloneable
{
- /**
+ /*
* The value of the field
*/
public double val;
- /**
+ /*
* @param value of field
*/
public PGmoney(double value)
val = value;
}
- /**
+ /*
* This is called mainly from the other geometric types, when a
* point is imbeded within their definition.
*
setValue(value);
}
- /**
+ /*
* Required by the driver
*/
public PGmoney()
setType("money");
}
- /**
+ /*
* @param s Definition of this point in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
}
}
- /**
+ /*
* @param obj Object to compare with
* @return true if the two boxes are identical
*/
return false;
}
- /**
+ /*
* This must be overidden to allow the object to be cloned
*/
public Object clone()
return new PGmoney(val);
}
- /**
+ /*
* @return the PGpoint in the syntax expected by org.postgresql
*/
public String getValue()
import java.sql.*;
import java.util.*;
-/**
+/*
* org.postgresql.PG_Object is a class used to describe unknown types
* An unknown type is any type that is unknown by JDBC Standards
*
protected String type;
protected String value;
- /**
+ /*
* This is called by org.postgresql.Connection.getObject() to create the
* object.
*/
public PGobject()
{}
- /**
+ /*
* This method sets the type of this object.
*
* <p>It should not be extended by subclasses, hence its final
this.type = type;
}
- /**
+ /*
* This method sets the value of this object. It must be overidden.
*
* @param value a string representation of the value of the object
this.value = value;
}
- /**
+ /*
* As this cannot change during the life of the object, it's final.
* @return the type name of this object
*/
return type;
}
- /**
+ /*
* This must be overidden, to return the value of the object, in the
* form required by org.postgresql.
* @return the value of this object
return value;
}
- /**
+ /*
* This must be overidden to allow comparisons of objects
* @param obj Object to compare with
* @return true if the two boxes are identical
return false;
}
- /**
+ /*
* This must be overidden to allow the object to be cloned
*/
public Object clone()
return obj;
}
- /**
+ /*
* This is defined here, so user code need not overide it.
* @return the value of this object, in the syntax expected by org.postgresql
*/
import java.sql.*;
import java.util.*;
-/**
+/*
* This class is used to tokenize the text output of org.postgres.
*
* <p>It's mainly used by the geometric classes, but is useful in parsing any
// Our tokens
protected Vector tokens;
- /**
+ /*
* Create a tokeniser.
*
* <p>We could have used StringTokenizer to do this, however, we needed to
tokenize(string, delim);
}
- /**
+ /*
* This resets this tokenizer with a new string and/or delimiter.
*
* @param string containing tokens
return tokens.size();
}
- /**
+ /*
* @return the number of tokens available
*/
public int getSize()
return tokens.size();
}
- /**
+ /*
* @param n Token number ( 0 ... getSize()-1 )
* @return The token value
*/
return (String)tokens.elementAt(n);
}
- /**
+ /*
* This returns a new tokenizer based on one of our tokens.
*
* The geometric datatypes use this to process nested tokens (usually
return new PGtokenizer(getToken(n), delim);
}
- /**
+ /*
* This removes the lead/trailing strings from a string
* @param s Source string
* @param l Leading string to remove
return s;
}
- /**
+ /*
* This removes the lead/trailing strings from all tokens
* @param l Leading string to remove
* @param t Trailing string to remove
}
}
- /**
+ /*
* Removes ( and ) from the beginning and end of a string
* @param s String to remove from
* @return String without the ( or )
return remove(s, "(", ")");
}
- /**
+ /*
* Removes ( and ) from the beginning and end of all tokens
* @return String without the ( or )
*/
remove("(", ")");
}
- /**
+ /*
* Removes [ and ] from the beginning and end of a string
* @param s String to remove from
* @return String without the [ or ]
return remove(s, "[", "]");
}
- /**
+ /*
* Removes [ and ] from the beginning and end of all tokens
* @return String without the [ or ]
*/
remove("[", "]");
}
- /**
+ /*
* Removes < and > from the beginning and end of a string
* @param s String to remove from
* @return String without the < or >
return remove(s, "<", ">");
}
- /**
+ /*
* Removes < and > from the beginning and end of all tokens
* @return String without the < or >
*/
import java.io.*;
import java.sql.*;
-/**
+/*
* This class extends SQLException, and provides our internationalisation handling
*/
public class PSQLException extends SQLException
{
private String message;
- /**
+ /*
* This provides the same functionality to SQLException
* @param error Error string
*/
translate(error, null);
}
- /**
+ /*
* A more generic entry point.
* @param error Error string or standard message id
* @param args Array of arguments
translate(error, args);
}
- /**
+ /*
* Helper version for 1 arg
*/
public PSQLException(String error, Object arg)
translate(error, argv);
}
- /**
+ /*
* Helper version for 1 arg. This is used for debug purposes only with
* some unusual Exception's. It allows the originiating Exceptions stack
* trace to be returned.
translate(error, argv);
}
- /**
+ /*
* Helper version for 2 args
*/
public PSQLException(String error, Object arg1, Object arg2)
message = MessageTranslator.translate(error, args);
}
- /**
+ /*
* Overides Throwable
*/
public String getLocalizedMessage()
return message;
}
- /**
+ /*
* Overides Throwable
*/
public String getMessage()
return message;
}
- /**
+ /*
* Overides Object
*/
public String toString()
import java.util.*;
import java.sql.*;
-/**
+/*
* This class uses PostgreSQL's object oriented features to store Java Objects.<p>
*
* It does this by mapping a Java Class name to a table in the database. Each
// This is the Class for this serialzed object
protected Class ourClass;
- /**
+ /*
* This creates an instance that can be used to serialize or deserialize
* a Java object from a PostgreSQL table.
*/
// Finally cache the fields within the table
}
- /**
+ /*
* Constructor when Object is passed in
*/
public Serialize(org.postgresql.Connection c, Object o) throws SQLException
this(c, o.getClass().getName());
}
- /**
+ /*
* Constructor when Class is passed in
*/
public Serialize(org.postgresql.Connection c, Class cls) throws SQLException
this(c, cls.getName());
}
- /**
+ /*
* This fetches an object from a table, given it's OID
* @param oid The oid of the object
* @return Object relating to oid
}
}
- /**
+ /*
* This stores an object into a table, returning it's OID.<p>
*
* If the object has an int called OID, and it is > 0, then
}
}
- /**
+ /*
* Escape literal single quote and backslashes embedded in strings/chars.
* Otherwise, postgres will bomb on the single quote and remove the
* the backslashes.
return s;
}
- /**
+ /*
* This method is not used by the driver, but it creates a table, given
* a Serializable Java Object. It should be used before serializing any
* objects.
create(con, o.getClass());
}
- /**
+ /*
* This method is not used by the driver, but it creates a table, given
* a Serializable Java Object. It should be used before serializing any
* objects.
{"byte", "int2"}
};
- /**
+ /*
* This converts a Java Class name to a org.postgresql table, by replacing . with
* _<p>
*
}
- /**
+ /*
* This converts a org.postgresql table to a Java Class name, by replacing _ with
* .<p>
*
package org.postgresql.util;
-/**
+/*
* This class provides us with the ability to encrypt passwords when sent
* over the network stream
*
return (out);
}
- /**
+ /*
* <P>Encrypt a password given the cleartext password and a "salt".</P>
* @param salt A two-character string representing the salt used to
* iterate the encryption engine in lots of different ways. If you
return (buffer.toString());
}
- /**
+ /*
* <P>Encrypt a password given the cleartext password. This method
* generates a random salt using the 'java.util.Random' class.</P>
* @param original The password to be encrypted.
return crypt(salt, original);
}
- /**
+ /*
* <P>Check that <I>enteredPassword</I> encrypts to
* <I>encryptedPassword</I>.</P>
* @param encryptedPassword The <I>encryptedPassword</I>. The first
-/**
+/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided
* that the following conditions are met:
*
* Copyright 1999 (C) Exoffice Technologies Inc. All Rights Reserved.
*
-* $Id: ClientConnection.java,v 1.2 2001/10/25 06:00:05 momjian Exp $
+* $Id: ClientConnection.java,v 1.3 2001/11/19 22:33:39 momjian Exp $
*/
import java.sql.*;
-/**
+/*
* Encapsulates an application's view of an XA/pooled connection.
* The XA connection is managed by the application server through it's
* {@link javax.sql.XAConnection} interface. The underlying JDBC
{
- /**
+ /*
* The pooled XA connection that created this client connection
* and should be used to report closure and fatal errors.
*/
private XAConnectionImpl _xaConn;
- /**
+ /*
* This identifier was handed on to use when we were created by
* {@link XAConnection}. If since then the XA connection was asked
* to create another connection or was closed, our identifier will
- /**
+ /*
* Construct a new client connection to provide access to the
* underlying JDBC connection (<tt>underlying</tt>) on behalf of
* an XA/pooled connection (<tt>xaConn<tt/>). The pooled connection
}
- /**
+ /*
* Called by {@link XAConnectionImpl} to terminate this connection
* by dissociating it from the underlying JDBC connection.
* The application would call {@link #close} but {@link
}
- /**
+ /*
* Called when an exception is thrown by the underlying connection
* to determine whether the exception is critical or not. If the
* exception is critical, notifies the XA connection to forget
}
- /**
+ /*
* Called to retrieve the underlying JDBC connection. Actual JDBC
* operations are performed against it. Throws an SQLException if
* this connection has been closed.
-/**
+/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided
* that the following conditions are met:
*
* Copyright 1999 (C) Exoffice Technologies Inc. All Rights Reserved.
*
-* $Id: TwoPhaseConnection.java,v 1.2 2001/10/25 06:00:05 momjian Exp $
+* $Id: TwoPhaseConnection.java,v 1.3 2001/11/19 22:33:39 momjian Exp $
*/
import java.sql.SQLException;
-/**
+/*
* Defines two-phase commit support for a JDBC connection used by
* {@link XAConnection}. A JDBC connection that can implement any of
* these features should extend this interface and attempt to
{
- /**
+ /*
* Enables or disables transaction demarcation through SQL commit
* and rollback. When the connection falls under control of
* {@link XAConnection}, SQL commit/rollback commands will be
public void enableSQLTransactions( boolean flag );
- /**
+ /*
* Called to prepare the transaction for commit. Returns true if
* the transaction is prepared, false if the transaction is
* read-only. If the transaction has been marked for rollback,
throws SQLException;
- /**
+ /*
* Returns true if the error issued by this connection is a
* critical error and the connection should be terminated.
*
-/**
+/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided
* that the following conditions are met:
*
* Copyright 1999 (C) Exoffice Technologies Inc. All Rights Reserved.
*
-* $Id: TxConnection.java,v 1.2 2001/10/25 06:00:05 momjian Exp $
+* $Id: TxConnection.java,v 1.3 2001/11/19 22:33:39 momjian Exp $
*/
import javax.transaction.xa.Xid;
-/**
+/*
* Describes an open connection associated with a transaction. When a
* transaction is opened for a connection, this record is created for
* the connection. It indicates the underlying JDBC connection and
{
- /**
+ /*
* The Xid of the transactions. Connections that are not
* associated with a transaction are not represented here.
*/
Xid xid;
- /**
+ /*
* Holds the underlying JDBC connection for as long as this
* connection is useable. If the connection has been rolled back,
* timed out or had any other error, this variable will null
- /**
+ /*
* Indicates the clock time (in ms) when the transaction should
* time out. The transaction times out when
* <tt>System.currentTimeMillis() > timeout</tt>.
long timeout;
- /**
+ /*
* Indicates the clock time (in ms) when the transaction started.
*/
long started;
- /**
+ /*
* Reference counter indicates how many XA connections share this
* underlying connection and transaction. Always one or more.
*/
int count;
- /**
+ /*
* True if the transaction has failed due to time out.
*/
boolean timedOut;
- /**
+ /*
* True if the transaction has already been prepared.
*/
boolean prepared;
- /**
+ /*
* True if the transaction has been prepared and found out to be
* read-only. Read-only transactions do not require commit/rollback.
*/
-/**
+/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided
* that the following conditions are met:
*
* Copyright 1999 (C) Exoffice Technologies Inc. All Rights Reserved.
*
-* $Id: XAConnectionImpl.java,v 1.2 2001/10/25 06:00:05 momjian Exp $
+* $Id: XAConnectionImpl.java,v 1.3 2001/11/19 22:33:39 momjian Exp $
*/
import javax.transaction.xa.XAException;
-/**
+/*
* Implements an X/A connection that can be pooled and managed from
* inside a transaction monitor. This is the XA connection returned
* to the application server from the {@link XADataSourceImpl} and
{
- /**
+ /*
* This is the underlying JDBC connection represented
* by this pooled connection. This variable may initially be null,
* in which case {@link #getUnderlying} will return a new
Connection _underlying;
- /**
+ /*
* If this connection is part of a global transaction, this
* object identifies the transaction. The transaction's
* underlying JDBC connection is exposed through this object and
private TxConnection _txConn;
- /**
+ /*
* The client connection last handed to the application. If the
* application calls {@link #getConnection} again, we should hand
* out a new client connection and render the previous one closed.
//private ClientConnection _clientConn;
- /**
+ /*
* An event listener can be registered and notified when the
* client connection has been closed by the application or a
* fatal error rendered it unuseable.
private ConnectionEventListener _listener;
- /**
+ /*
* The resource manager is used to share connections within the
* same transaction.
*/
private XADataSourceImpl _resManager;
- /**
+ /*
* This is an identifier we hand to the client connection when we
* create it. When the client connection asks for the underlying
* connection, we compare the identifiers. If since that point we
private int _clientId = 1;
- /**
+ /*
* Construct a new XA/pooled connection with the underlying JDBC
* connection suitable for this driver only. This is a one to one
* mapping between this connection and the underlying connection.
}
- /**
+ /*
* Called by {@link ClientConnection} to notify that the application
* has attempted to close the connection. After this call, the client
* connection is no longer useable and this pooled connection can be
}
- /**
+ /*
* Called by {@link ClientConnection} to notify that an error
* occured with the underlying connection. If the error is
* critical, the underlying connection is closed and the listener
}
- /**
+ /*
* Returns true if this connection is inside a global transaction.
* If the connection is inside a global transaction it will not
* allow commit/rollback directly from the {@link
return ( _txConn != null );
}
-
- /**
+ /*
* Called to obtain the underlying connections. If this connection
* is part of a transaction, the transction's underlying connection
* is returned, or an exception is thrown if the connection was
-/**
+/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided
* that the following conditions are met:
*
* Copyright 1999 (C) Exoffice Technologies Inc. All Rights Reserved.
*
-* $Id: XADataSourceImpl.java,v 1.2 2001/10/25 06:00:05 momjian Exp $
+* $Id: XADataSourceImpl.java,v 1.3 2001/11/19 22:33:39 momjian Exp $
*/
-/**
+/*
* Implements a JDBC 2.0 {@link XADataSource} for any JDBC driver
* with JNDI persistance support. The base implementation is actually
* provided by a different {@link DataSource} class; although this is
{
- /**
+ /*
* Maps underlying JDBC connections into global transaction Xids.
*/
private transient Hashtable _txConnections = new Hashtable();
- /**
+ /*
* This is a pool of free underlying JDBC connections. If two
* XA connections are used in the same transaction, the second
* one will make its underlying JDBC connection available to
private transient Stack _pool = new Stack();
- /**
+ /*
* A background deamon thread terminating connections that have
* timed out.
*/
private transient Thread _background;
- /**
+ /*
* The default timeout for all new transactions.
*/
private int _txTimeout = DEFAULT_TX_TIMEOUT;
- /**
+ /*
* The default timeout for all new transactions is 10 seconds.
*/
public final static int DEFAULT_TX_TIMEOUT = 10;
- /**
+ /*
* Implementation details:
* If two XAConnections are associated with the same transaction
* (one with a start the other with a join) they must use the
}
- /**
+ /*
* Returns the default timeout for all transactions.
*/
public int getTransactionTimeout()
}
- /**
+ /*
* This method is defined in the interface and implemented in the
* derived class, we re-define it just to make sure it does not
* throw an {@link SQLException} and that we do not need to
public abstract java.io.PrintWriter getLogWriter();
- /**
+ /*
* Sets the default timeout for all transactions. The timeout is
* specified in seconds. Use zero for the default timeout. Calling
* this method does not affect transactions in progress.
}
- /**
+ /*
* Returns an underlying connection for the global transaction,
* if one has been associated before.
*
}
- /**
+ /*
* Associates the global transaction with an underlying connection,
* or dissociate it when null is passed.
*
}
- /**
+ /*
* Release an unused connection back to the pool. If an XA
* connection has been asked to join an existing transaction,
* it will no longer use it's own connection and make it available
}
- /**
+ /*
* Creates a new underlying connection. Used by XA connection
* that lost it's underlying connection when joining a
* transaction and is now asked to produce a new connection.
}
- /**
+ /*
* XXX Not fully implemented yet and no code to really
* test it.
*/
}
- /**
+ /*
* Returns the transaction isolation level to use with all newly
* created transactions, or {@link Connection#TRANSACTION_NONE}
* if using the driver's default isolation level.
projects / postgresql / commitdiff