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");
+
projects / users / c2main / postgres.git / commitdiff