mirror of https://github.com/postgres/postgres
the versioning works. There's also a new utils directory used by MakefileREL7_1_STABLE
Peter Mount
25 years ago
parent
f20d2a87fb
commit
f41dcbe4d8
@ -1,210 +1,213 @@ |
||||
package example; |
||||
|
||||
import java.io.*; |
||||
import java.sql.*; |
||||
import java.text.*; |
||||
|
||||
/** |
||||
* This example application demonstrates some of the drivers other features |
||||
* by implementing a simple psql replacement in Java. |
||||
* |
||||
*/ |
||||
|
||||
public class psql |
||||
{ |
||||
Connection db; // The connection to the database
|
||||
Statement st; // Our statement to run queries with
|
||||
DatabaseMetaData dbmd; // This defines the structure of the database
|
||||
|
||||
public psql(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException |
||||
{ |
||||
String url = args[0]; |
||||
String usr = args[1]; |
||||
String pwd = args[2]; |
||||
|
||||
// Load the driver
|
||||
Class.forName("org.postgresql.Driver"); |
||||
|
||||
// Connect to database
|
||||
System.out.println("Connecting to Database URL = " + url); |
||||
db = DriverManager.getConnection(url, usr, pwd); |
||||
|
||||
dbmd = db.getMetaData(); |
||||
st = db.createStatement(); |
||||
|
||||
// This prints the backend's version
|
||||
System.out.println("Connected to "+dbmd.getDatabaseProductName()+" "+dbmd.getDatabaseProductVersion()); |
||||
|
||||
System.out.println(); |
||||
|
||||
// This provides us the means of reading from stdin
|
||||
StreamTokenizer input = new StreamTokenizer(new InputStreamReader(System.in)); |
||||
input.resetSyntax(); |
||||
input.slashSlashComments(true); // allow // as a comment delimiter
|
||||
input.eolIsSignificant(false); // treat eol's as spaces
|
||||
input.wordChars(32,126); |
||||
input.whitespaceChars(59,59); |
||||
input.quoteChar(39); |
||||
|
||||
// Now the main loop.
|
||||
int tt=0,lineno=1; |
||||
while(tt!=StreamTokenizer.TT_EOF) { |
||||
System.out.print("["+lineno+"] "); |
||||
System.out.flush(); |
||||
|
||||
// Here, we trap SQLException so they don't terminate the application
|
||||
try { |
||||
if((tt=input.nextToken())==StreamTokenizer.TT_WORD) { |
||||
processLine(input.sval); |
||||
lineno++; |
||||
} |
||||
} catch(SQLException ex) { |
||||
System.out.println(ex.getMessage()); |
||||
} |
||||
} |
||||
|
||||
System.out.println("Now closing the connection"); |
||||
st.close(); |
||||
db.close(); |
||||
|
||||
} |
||||
|
||||
/** |
||||
* This processes a statement |
||||
*/ |
||||
public void processLine(String line) throws SQLException |
||||
{ |
||||
if(line.startsWith("\\")) { |
||||
processSlashCommand(line); |
||||
return; |
||||
} |
||||
|
||||
boolean type = st.execute(line); |
||||
boolean loop=true; |
||||
while(loop) { |
||||
if(type) { |
||||
// A ResultSet was returned
|
||||
ResultSet rs=st.getResultSet(); |
||||
displayResult(rs); |
||||
} else { |
||||
int count = st.getUpdateCount(); |
||||
|
||||
if(count==-1) { |
||||
// This indicates nothing left
|
||||
loop=false; |
||||
} else { |
||||
// An update count was returned
|
||||
System.out.println("Updated "+st.getUpdateCount()+" rows"); |
||||
} |
||||
} |
||||
|
||||
if(loop) |
||||
type = st.getMoreResults(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This displays a result set. |
||||
* Note: it closes the result once complete. |
||||
*/ |
||||
public void displayResult(ResultSet rs) throws SQLException |
||||
{ |
||||
ResultSetMetaData rsmd = rs.getMetaData(); |
||||
|
||||
// Print the result column names
|
||||
int cols = rsmd.getColumnCount(); |
||||
for(int i=1;i<=cols;i++) |
||||
System.out.print(rsmd.getColumnLabel(i)+(i<cols?"\t":"\n")); |
||||
|
||||
// now the results
|
||||
while(rs.next()) { |
||||
for(int i=1;i<=cols;i++) { |
||||
Object o = rs.getObject(i); |
||||
if(rs.wasNull()) |
||||
System.out.print("{null}"+(i<cols?"\t":"\n")); |
||||
else |
||||
System.out.print(o.toString()+(i<cols?"\t":"\n")); |
||||
} |
||||
} |
||||
|
||||
// finally close the result set
|
||||
rs.close(); |
||||
} |
||||
|
||||
/** |
||||
* This process / commands (for now just /d) |
||||
*/ |
||||
public void processSlashCommand(String line) throws SQLException |
||||
{ |
||||
if(line.startsWith("\\d")) { |
||||
|
||||
if(line.startsWith("\\d ")) { |
||||
// Display details about a table
|
||||
String table=line.substring(3); |
||||
displayResult(dbmd.getColumns(null,null,table,"%")); |
||||
} else { |
||||
String types[] = null; |
||||
if(line.equals("\\d")) |
||||
types=allUserTables; |
||||
else if(line.equals("\\di")) |
||||
types=usrIndices; |
||||
else if(line.equals("\\dt")) |
||||
types=usrTables; |
||||
else if(line.equals("\\ds")) |
||||
types=usrSequences; |
||||
else if(line.equals("\\dS")) |
||||
types=sysTables; |
||||
else |
||||
throw new SQLException("Unsupported \\d command: "+line); |
||||
|
||||
// Display details about all system tables
|
||||
//
|
||||
// Note: the first two arguments are ignored. To keep to the spec,
|
||||
// you must put null here
|
||||
//
|
||||
displayResult(dbmd.getTables(null,null,"%",types)); |
||||
} |
||||
} else |
||||
throw new SQLException("Unsupported \\ command: "+line); |
||||
} |
||||
|
||||
private static final String allUserTables[] = {"TABLE","INDEX","SEQUENCE"}; |
||||
private static final String usrIndices[] = {"INDEX"}; |
||||
private static final String usrTables[] = {"TABLE"}; |
||||
private static final String usrSequences[] = {"SEQUENCE"}; |
||||
private static final String sysTables[] = {"SYSTEM TABLE","SYSTEM INDEX"}; |
||||
|
||||
/** |
||||
* Display some instructions on how to run the example |
||||
*/ |
||||
public static void instructions() |
||||
{ |
||||
System.out.println("\nThis example shows how some of the other JDBC features work within the\ndriver. It does this by implementing a very simple psql equivalent in java.\nNot everything that psql does is implemented.\n"); |
||||
System.out.println("Useage:\n java example.psql jdbc:postgresql:database user password [debug]\n\nThe debug field can be anything. It's presence will enable DriverManager's\ndebug trace. Unless you want to see screens of items, don't put anything in\nhere."); |
||||
System.exit(1); |
||||
} |
||||
|
||||
/** |
||||
* This little lot starts the test |
||||
*/ |
||||
public static void main(String args[]) |
||||
{ |
||||
System.out.println("PostgreSQL psql example v6.3 rev 1\n"); |
||||
|
||||
if(args.length<3) |
||||
instructions(); |
||||
|
||||
// This line outputs debug information to stderr. To enable this, simply
|
||||
// add an extra parameter to the command line
|
||||
if(args.length>3) |
||||
DriverManager.setLogStream(System.err); |
||||
|
||||
// Now run the tests
|
||||
try { |
||||
psql test = new psql(args); |
||||
} catch(Exception ex) { |
||||
System.err.println("Exception caught.\n"+ex); |
||||
ex.printStackTrace(); |
||||
} |
||||
} |
||||
} |
||||
package example; |
||||
|
||||
import java.io.*; |
||||
import java.sql.*; |
||||
import java.text.*; |
||||
|
||||
/** |
||||
* This example application demonstrates some of the drivers other features |
||||
* by implementing a simple psql replacement in Java. |
||||
* |
||||
*/ |
||||
|
||||
public class psql |
||||
{ |
||||
Connection db; // The connection to the database
|
||||
Statement st; // Our statement to run queries with
|
||||
DatabaseMetaData dbmd; // This defines the structure of the database
|
||||
boolean done = false; // Added by CWJ to permit \q command
|
||||
|
||||
public psql(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException |
||||
{ |
||||
String url = args[0]; |
||||
String usr = args[1]; |
||||
String pwd = args[2]; |
||||
|
||||
// Load the driver
|
||||
Class.forName("org.postgresql.Driver"); |
||||
|
||||
// Connect to database
|
||||
System.out.println("Connecting to Database URL = " + url); |
||||
db = DriverManager.getConnection(url, usr, pwd); |
||||
|
||||
dbmd = db.getMetaData(); |
||||
st = db.createStatement(); |
||||
|
||||
// This prints the backend's version
|
||||
System.out.println("Connected to "+dbmd.getDatabaseProductName()+" "+dbmd.getDatabaseProductVersion()); |
||||
|
||||
System.out.println(); |
||||
|
||||
// This provides us the means of reading from stdin
|
||||
StreamTokenizer input = new StreamTokenizer(new InputStreamReader(System.in)); |
||||
input.resetSyntax(); |
||||
input.slashSlashComments(true); // allow // as a comment delimiter
|
||||
input.eolIsSignificant(false); // treat eol's as spaces
|
||||
input.wordChars(32,126); |
||||
input.whitespaceChars(59,59); |
||||
// input.quoteChar(39); *** CWJ: messes up literals in query string ***
|
||||
|
||||
// Now the main loop.
|
||||
int tt=0,lineno=1; |
||||
while(tt!=StreamTokenizer.TT_EOF && ! done) { // done added by CWJ to permit \q command
|
||||
System.out.print("["+lineno+"] "); |
||||
System.out.flush(); |
||||
|
||||
// Here, we trap SQLException so they don't terminate the application
|
||||
try { |
||||
if((tt=input.nextToken())==StreamTokenizer.TT_WORD) { |
||||
processLine(input.sval); |
||||
lineno++; |
||||
} |
||||
} catch(SQLException ex) { |
||||
System.out.println(ex.getMessage()); |
||||
} |
||||
} |
||||
|
||||
System.out.println("Now closing the connection"); |
||||
st.close(); |
||||
db.close(); |
||||
|
||||
} |
||||
|
||||
/** |
||||
* This processes a statement |
||||
*/ |
||||
public void processLine(String line) throws SQLException |
||||
{ |
||||
if(line.startsWith("\\")) { |
||||
processSlashCommand(line); |
||||
return; |
||||
} |
||||
|
||||
boolean type = st.execute(line); |
||||
boolean loop=true; |
||||
while(loop) { |
||||
if(type) { |
||||
// A ResultSet was returned
|
||||
ResultSet rs=st.getResultSet(); |
||||
displayResult(rs); |
||||
} else { |
||||
int count = st.getUpdateCount(); |
||||
|
||||
if(count==-1) { |
||||
// This indicates nothing left
|
||||
loop=false; |
||||
} else { |
||||
// An update count was returned
|
||||
System.out.println("Updated "+st.getUpdateCount()+" rows"); |
||||
} |
||||
} |
||||
|
||||
if(loop) |
||||
type = st.getMoreResults(); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* This displays a result set. |
||||
* Note: it closes the result once complete. |
||||
*/ |
||||
public void displayResult(ResultSet rs) throws SQLException |
||||
{ |
||||
ResultSetMetaData rsmd = rs.getMetaData(); |
||||
|
||||
// Print the result column names
|
||||
int cols = rsmd.getColumnCount(); |
||||
for(int i=1;i<=cols;i++) |
||||
System.out.print(rsmd.getColumnLabel(i)+(i<cols?"\t":"\n")); |
||||
|
||||
// now the results
|
||||
while(rs.next()) { |
||||
for(int i=1;i<=cols;i++) { |
||||
Object o = rs.getObject(i); |
||||
if(rs.wasNull()) |
||||
System.out.print("{null}"+(i<cols?"\t":"\n")); |
||||
else |
||||
System.out.print(o.toString()+(i<cols?"\t":"\n")); |
||||
} |
||||
} |
||||
|
||||
// finally close the result set
|
||||
rs.close(); |
||||
} |
||||
|
||||
/** |
||||
* This process / commands (for now just /d) |
||||
*/ |
||||
public void processSlashCommand(String line) throws SQLException |
||||
{ |
||||
if(line.startsWith("\\d")) { |
||||
|
||||
if(line.startsWith("\\d ")) { |
||||
// Display details about a table
|
||||
String table=line.substring(3); |
||||
displayResult(dbmd.getColumns(null,null,table,"%")); |
||||
} else { |
||||
String types[] = null; |
||||
if(line.equals("\\d")) |
||||
types=allUserTables; |
||||
else if(line.equals("\\di")) |
||||
types=usrIndices; |
||||
else if(line.equals("\\dt")) |
||||
types=usrTables; |
||||
else if(line.equals("\\ds")) |
||||
types=usrSequences; |
||||
else if(line.equals("\\dS")) |
||||
types=sysTables; |
||||
else |
||||
throw new SQLException("Unsupported \\d command: "+line); |
||||
|
||||
// Display details about all system tables
|
||||
//
|
||||
// Note: the first two arguments are ignored. To keep to the spec,
|
||||
// you must put null here
|
||||
//
|
||||
displayResult(dbmd.getTables(null,null,"%",types)); |
||||
} |
||||
} else if(line.equals("\\q")) // Added by CWJ to permit \q command
|
||||
done = true; |
||||
else |
||||
throw new SQLException("Unsupported \\ command: "+line); |
||||
} |
||||
|
||||
private static final String allUserTables[] = {"TABLE","INDEX","SEQUENCE"}; |
||||
private static final String usrIndices[] = {"INDEX"}; |
||||
private static final String usrTables[] = {"TABLE"}; |
||||
private static final String usrSequences[] = {"SEQUENCE"}; |
||||
private static final String sysTables[] = {"SYSTEM TABLE","SYSTEM INDEX"}; |
||||
|
||||
/** |
||||
* Display some instructions on how to run the example |
||||
*/ |
||||
public static void instructions() |
||||
{ |
||||
System.out.println("\nThis example shows how some of the other JDBC features work within the\ndriver. It does this by implementing a very simple psql equivalent in java.\nNot everything that psql does is implemented.\n"); |
||||
System.out.println("Useage:\n java example.psql jdbc:postgresql:database user password [debug]\n\nThe debug field can be anything. It's presence will enable DriverManager's\ndebug trace. Unless you want to see screens of items, don't put anything in\nhere."); |
||||
System.exit(1); |
||||
} |
||||
|
||||
/** |
||||
* This little lot starts the test |
||||
*/ |
||||
public static void main(String args[]) |
||||
{ |
||||
System.out.println("PostgreSQL psql example v6.3 rev 1\n"); |
||||
|
||||
if(args.length<3) |
||||
instructions(); |
||||
|
||||
// This line outputs debug information to stderr. To enable this, simply
|
||||
// add an extra parameter to the command line
|
||||
if(args.length>3) |
||||
DriverManager.setLogStream(System.err); |
||||
|
||||
// Now run the tests
|
||||
try { |
||||
psql test = new psql(args); |
||||
} catch(Exception ex) { |
||||
System.err.println("Exception caught.\n"+ex); |
||||
ex.printStackTrace(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
@ -0,0 +1,585 @@ |
||||
/** |
||||
* Redistribution and use of this software and associated documentation |
||||
* ("Software"), with or without modification, are permitted provided |
||||
* that the following conditions are met: |
||||
* |
||||
* 1. Redistributions of source code must retain copyright |
||||
* statements and notices. Redistributions must also contain a |
||||
* copy of this document. |
||||
* |
||||
* 2. Redistributions in binary form must reproduce the |
||||
* above copyright notice, this list of conditions and the |
||||
* following disclaimer in the documentation and/or other |
||||
* materials provided with the distribution. |
||||
* |
||||
* 3. The name "Exolab" must not be used to endorse or promote |
||||
* products derived from this Software without prior written |
||||
* permission of Exoffice Technologies. For written permission, |
||||
* please contact info@exolab.org. |
||||
* |
||||
* 4. Products derived from this Software may not be called "Exolab" |
||||
* nor may "Exolab" appear in their names without prior written |
||||
* permission of Exoffice Technologies. Exolab is a registered |
||||
* trademark of Exoffice Technologies. |
||||
* |
||||
* 5. Due credit should be given to the Exolab Project |
||||
* (http://www.exolab.org/).
|
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY EXOFFICE TECHNOLOGIES AND CONTRIBUTORS |
||||
* ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT |
||||
* NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
||||
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL |
||||
* EXOFFICE TECHNOLOGIES OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, |
||||
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
||||
* OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
* |
||||
* Copyright 1999 (C) Exoffice Technologies Inc. All Rights Reserved. |
||||
* |
||||
* $Id: PostgresqlDataSource.java,v 1.1 2000/10/12 08:55:24 peter Exp $ |
||||
*/ |
||||
|
||||
|
||||
package org.postgresql; |
||||
|
||||
|
||||
import java.io.PrintWriter; |
||||
import java.io.Serializable; |
||||
import java.util.Properties; |
||||
import java.util.Hashtable; |
||||
import java.sql.Connection; |
||||
import java.sql.SQLException; |
||||
import java.sql.DriverManager; |
||||
import java.rmi.Remote; |
||||
import javax.sql.DataSource; |
||||
import javax.naming.Referenceable; |
||||
import javax.naming.Reference; |
||||
import javax.naming.StringRefAddr; |
||||
import javax.naming.RefAddr; |
||||
import javax.naming.Context; |
||||
import javax.naming.Name; |
||||
import javax.naming.NamingException; |
||||
import javax.naming.spi.ObjectFactory; |
||||
import postgresql.util.PSQLException; |
||||
import 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 |
||||
* used the designated DataSource interface to obtain them. |
||||
* <p> |
||||
* The supported data source properties are: |
||||
* <pre> |
||||
* description (optional) |
||||
* databaseName (required) |
||||
* loginTimeout (optional) |
||||
* user (optional) |
||||
* password (optional) |
||||
* serverName (optional) |
||||
* portNumber (optional) |
||||
* transactionTimeout (optional for XA connections) |
||||
* </pre> |
||||
* This data source may be serialized and stored in a JNDI |
||||
* directory. Example of how to create a new data source and |
||||
* register it with JNDI: |
||||
* <pre> |
||||
* PostgresqlDataSource ds; |
||||
* InitialContext ctx; |
||||
* |
||||
* ds = new PostgresqlDataSource(); |
||||
* ds.setDatabaseName( "test" ); |
||||
* ds.setUser( "me" ); |
||||
* ds.setPassword( "secret" ); |
||||
* ctx = new InitialContext(); |
||||
* ctx.rebind( "/comp/jdbc/test", ds ); |
||||
* </pre> |
||||
* Example for obtaining the data source from JNDI and |
||||
* opening a new connections: |
||||
* <pre> |
||||
* InitialContext ctx; |
||||
* DataSource ds; |
||||
* |
||||
* ctx = new InitialContext(); |
||||
* ds = (DataSource) ctx.lookup( "/comp/jdbc/test" ); |
||||
* ds.getConnection(); |
||||
* </pre> |
||||
* |
||||
* |
||||
* @author <a href="arkin@exoffice.com">Assaf Arkin</a> |
||||
* @version 1.0 |
||||
* @see XADataSourceImpl |
||||
* @see DataSource |
||||
* @see Connection |
||||
*/ |
||||
public class PostgresqlDataSource |
||||
extends XADataSourceImpl |
||||
implements DataSource, Referenceable, |
||||
ObjectFactory, Serializable |
||||
{ |
||||
|
||||
|
||||
/** |
||||
* 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 |
||||
* and will be passed to the driver. May be null. |
||||
*/ |
||||
private transient PrintWriter _logWriter; |
||||
|
||||
|
||||
/** |
||||
* Each datasource maintains it's own driver, in case of |
||||
* driver-specific setup (e.g. pools, log writer). |
||||
*/ |
||||
private transient postgresql.Driver _driver; |
||||
|
||||
|
||||
|
||||
|
||||
public PostgresqlDataSource() |
||||
{ |
||||
_logWriter = DriverManager.getLogWriter(); |
||||
_loginTimeout = DriverManager.getLoginTimeout(); |
||||
} |
||||
|
||||
|
||||
public Connection getConnection() |
||||
throws SQLException |
||||
{ |
||||
// Uses the username and password specified for the datasource.
|
||||
return getConnection( _user, _password ); |
||||
} |
||||
|
||||
|
||||
public synchronized Connection getConnection( String user, String password ) |
||||
throws SQLException |
||||
{ |
||||
Connection conn; |
||||
Properties info; |
||||
String url; |
||||
|
||||
if ( _driver == null ) { |
||||
try { |
||||
// Constructs a driver for use just by this data source
|
||||
// which will produce TwoPhaseConnection-s. This driver
|
||||
// is not registered with the driver manager.
|
||||
_driver = new postgresql.Driver(); |
||||
_driver.setLogWriter( _logWriter ); |
||||
} catch ( SQLException except ) { |
||||
if ( _logWriter != null ) |
||||
_logWriter.println( "DataSource: Failed to initialize JDBC driver: " + except ); |
||||
throw except; |
||||
} |
||||
} |
||||
|
||||
// Use info to supply properties that are not in the URL.
|
||||
info = new Properties(); |
||||
info.put( "loginTimeout", Integer.toString( _loginTimeout ) ); |
||||
|
||||
// DriverManager will do that and not rely on the URL alone.
|
||||
if ( user == null ) { |
||||
user = _user; |
||||
password = _password; |
||||
} |
||||
if ( user == null || password == null ) |
||||
throw new PSQLException( "postgresql.ds.userpswd" ); |
||||
info.put( "user", user ); |
||||
info.put( "password", password ); |
||||
|
||||
if ( _serverName != null ) |
||||
info.put( "PGHOST", _serverName ); |
||||
if ( _portNumber != DEFAULT_PORT ) |
||||
info.put( "PGPORT", Integer.toString( _portNumber ) ); |
||||
if ( _databaseName != null ) |
||||
info.put( "PGDBNAME", _databaseName ); |
||||
|
||||
// Construct the URL suitable for this driver.
|
||||
url = "jdbc:postgresql:"; |
||||
|
||||
// Attempt to establish a connection. Report a successful
|
||||
// attempt or a failure.
|
||||
try { |
||||
conn = _driver.connect( url, info ); |
||||
if ( ! ( conn instanceof postgresql.jdbc2.Connection ) ) { |
||||
if ( _logWriter != null ) |
||||
_logWriter.println( "DataSource: JDBC 1 connections not supported" ); |
||||
throw new PSQLException( "postgresql.ds.onlyjdbc2" ); |
||||
} |
||||
} catch ( SQLException except ) { |
||||
if ( _logWriter != null ) |
||||
_logWriter.println( "DataSource: getConnection failed " + except ); |
||||
throw except; |
||||
} |
||||
if ( conn != null && _logWriter != null ) |
||||
_logWriter.println( "DataSource: getConnection returning " + conn ); |
||||
return conn; |
||||
} |
||||
|
||||
|
||||
public PrintWriter getLogWriter() |
||||
{ |
||||
return _logWriter; |
||||
} |
||||
|
||||
|
||||
public synchronized void setLogWriter( PrintWriter writer ) |
||||
{ |
||||
// Once a log writer has been set, we cannot set it since some
|
||||
// thread might be conditionally accessing it right now without
|
||||
// synchronizing.
|
||||
if ( writer != null ) { |
||||
if ( _driver != null ) |
||||
_driver.setLogWriter( writer ); |
||||
_logWriter = writer; |
||||
} |
||||
} |
||||
|
||||
|
||||
public void setLoginTimeout( int seconds ) |
||||
{ |
||||
_loginTimeout = seconds; |
||||
} |
||||
|
||||
|
||||
public synchronized int getLoginTimeout() |
||||
{ |
||||
return _loginTimeout; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Sets the name of the particular database on the server. |
||||
* The standard name for this property is <tt>databaseName</tt>. |
||||
* |
||||
* @param databaseName The name of the particular database on the server |
||||
*/ |
||||
public synchronized void setDatabaseName( String databaseName ) |
||||
{ |
||||
if ( databaseName == null ) |
||||
throw new NullPointerException( "DataSource: Argument 'databaseName' is null" ); |
||||
_databaseName = databaseName; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Returns the name of the particular database on the server. |
||||
* The standard name for this property is <tt>databaseName</tt>. |
||||
* |
||||
* @return The name of the particular database on the server |
||||
*/ |
||||
public String getDatabaseName() |
||||
{ |
||||
return _databaseName; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Sets the description of this datasource. |
||||
* The standard name for this property is <tt>description</tt>. |
||||
* |
||||
* @param description The description of this datasource |
||||
*/ |
||||
public synchronized void setDescription( String description ) |
||||
{ |
||||
if ( description == null ) |
||||
throw new NullPointerException( "DataSource: Argument 'description' is null" ); |
||||
_description = description; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Returns the description of this datasource. |
||||
* The standard name for this property is <tt>description</tt>. |
||||
* |
||||
* @return The description of this datasource |
||||
*/ |
||||
public String getDescription() |
||||
{ |
||||
return _description; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Sets the database password. |
||||
* The standard name for this property is <tt>password</tt>. |
||||
* |
||||
* @param password The database password |
||||
*/ |
||||
public synchronized void setPassword( String password ) |
||||
{ |
||||
_password = password; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Returns the database password. |
||||
* The standard name for this property is <tt>password</tt>. |
||||
* |
||||
* @return The database password |
||||
*/ |
||||
public String getPassword() |
||||
{ |
||||
return _password; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Sets the port number where a server is listening. |
||||
* The standard name for this property is <tt>portNumber</tt>. |
||||
* |
||||
* @param portNumber The port number where a server is listening |
||||
*/ |
||||
public synchronized void setPortNumber( int portNumber ) |
||||
{ |
||||
_portNumber = portNumber; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Returns the port number where a server is listening. |
||||
* The standard name for this property is <tt>portNumber</tt>. |
||||
* |
||||
* @return The port number where a server is listening |
||||
*/ |
||||
public int getPortNumber() |
||||
{ |
||||
return _portNumber; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Sets the database server name. |
||||
|
||||
* The standard name for this property is <tt>serverName</tt>. |
||||
* |
||||
* @param serverName The database server name |
||||
*/ |
||||
public synchronized void setServerName( String serverName ) |
||||
{ |
||||
_serverName = serverName; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Returns the database server name. |
||||
* The standard name for this property is <tt>serverName</tt>. |
||||
* |
||||
* @return The database server name |
||||
*/ |
||||
public String getServerName() |
||||
{ |
||||
return _serverName; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Sets the user's account name. |
||||
* The standard name for this property is <tt>user</tt>. |
||||
* |
||||
* @param user The user's account name |
||||
*/ |
||||
public synchronized void setUser( String user ) |
||||
{ |
||||
_user = user; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Returns the user's account name. |
||||
* The standard name for this property is <tt>user</tt>. |
||||
* |
||||
* @return The user's account name |
||||
*/ |
||||
public String getUser() |
||||
{ |
||||
return _user; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* 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 |
||||
* name, user name, etc are comapred. Setup properties like |
||||
* description, log writer, etc are not compared. |
||||
*/ |
||||
public synchronized boolean equals( Object other ) |
||||
{ |
||||
if ( other == this ) |
||||
return true; |
||||
if ( other == null || ! ( other instanceof PostgresqlDataSource ) ) |
||||
return false; |
||||
|
||||
PostgresqlDataSource with; |
||||
|
||||
with = (PostgresqlDataSource) other; |
||||
if ( _databaseName != null && _databaseName.equals( with._databaseName ) ) |
||||
if ( _portNumber == with._portNumber && |
||||
( ( _serverName == null && with._serverName == null ) || |
||||
( _serverName != null && _serverName.equals( with._serverName ) ) ) ) |
||||
if ( ( _user == null && with._user == null ) || |
||||
( _user != null && _password != null && _user.equals( with._user ) && |
||||
_password.equals( with._password ) ) ) |
||||
return true; |
||||
return false; |
||||
} |
||||
|
||||
|
||||
public String toString() |
||||
{ |
||||
if ( _description != null ) |
||||
return _description; |
||||
else { |
||||
String url; |
||||
|
||||
url = "jdbc:postgresql:"; |
||||
if ( _serverName != null ) { |
||||
if ( _portNumber == DEFAULT_PORT ) |
||||
url = url + "//" + _serverName + "/"; |
||||
else |
||||
url = url + "//" + _serverName + ":" + _portNumber + "/"; |
||||
} else if ( _portNumber != DEFAULT_PORT ) |
||||
url = url + "//localhost:" + _portNumber + "/"; |
||||
if ( _databaseName != null ) |
||||
url = url + _databaseName; |
||||
return "DataSource " + url; |
||||
} |
||||
} |
||||
|
||||
|
||||
public synchronized Reference getReference() |
||||
{ |
||||
Reference ref; |
||||
|
||||
// We use same object as factory.
|
||||
ref = new Reference( getClass().getName(), getClass().getName(), null ); |
||||
// Mandatory properties
|
||||
ref.add( new StringRefAddr( "description", _description ) ); |
||||
ref.add( new StringRefAddr( "databaseName", _databaseName ) ); |
||||
ref.add( new StringRefAddr( "loginTimeout", Integer.toString( _loginTimeout ) ) ); |
||||
// Optional properties
|
||||
if ( _user != null ) |
||||
ref.add( new StringRefAddr( "user", _user ) ); |
||||
if ( _password != null ) |
||||
ref.add( new StringRefAddr( "password", _password ) ); |
||||
if ( _serverName != null ) |
||||
ref.add( new StringRefAddr( "serverName", _serverName ) ); |
||||
if ( _portNumber != DEFAULT_PORT ) |
||||
ref.add( new StringRefAddr( "portNumber", Integer.toString( _portNumber ) ) ); |
||||
ref.add( new StringRefAddr( "transactionTimeout", Integer.toString( getTransactionTimeout() ) ) ); |
||||
return ref; |
||||
} |
||||
|
||||
|
||||
public Object getObjectInstance( Object refObj, Name name, Context nameCtx, Hashtable env ) |
||||
throws NamingException |
||||
{ |
||||
Reference ref; |
||||
|
||||
// Can only reconstruct from a reference.
|
||||
if ( refObj instanceof Reference ) { |
||||
ref = (Reference) refObj; |
||||
// Make sure reference is of datasource class.
|
||||
if ( ref.getClassName().equals( getClass().getName() ) ) { |
||||
|
||||
PostgresqlDataSource ds; |
||||
RefAddr addr; |
||||
|
||||
try { |
||||
ds = (PostgresqlDataSource) Class.forName( ref.getClassName() ).newInstance(); |
||||
} catch ( Exception except ) { |
||||
throw new NamingException( except.toString() ); |
||||
} |
||||
// Mandatory properties
|
||||
ds._description = (String) ref.get( "description" ).getContent(); |
||||
ds._databaseName = (String) ref.get( "databaseName" ).getContent(); |
||||
ds._loginTimeout = Integer.parseInt( (String) ref.get( "loginTimeout" ).getContent() ); |
||||
// Optional properties
|
||||
addr = ref.get( "user" ); |
||||
if ( addr != null ) |
||||
ds._user = (String) addr.getContent(); |
||||
addr = ref.get( "password" ); |
||||
if ( addr != null ) |
||||
ds._password = (String) addr.getContent(); |
||||
addr = ref.get( "serverName" ); |
||||
if ( addr != null ) |
||||
ds._serverName = (String) addr.getContent(); |
||||
addr = ref.get( "portNumber" ); |
||||
if ( addr != null ) |
||||
ds._portNumber = Integer.parseInt( (String) addr.getContent() ); |
||||
addr = ref.get( "transactionTimeout" ); |
||||
if ( addr != null ) |
||||
setTransactionTimeout( Integer.parseInt( (String) addr.getContent() ) ); |
||||
return ds; |
||||
|
||||
} else |
||||
throw new NamingException( "DataSource: Reference not constructed from class " + getClass().getName() ); |
||||
} else if ( refObj instanceof Remote ) |
||||
return refObj; |
||||
else |
||||
return null; |
||||
} |
||||
|
||||
|
||||
} |
||||
|
||||
@ -0,0 +1,74 @@ |
||||
# This is the italian version of some errors. Errors not in this file |
||||
# are handled by the parent errors.properties file. |
||||
# |
||||
# Daniele Arduini <darduini@deis.unibo.it> |
||||
# Wed Aug 9 12:18:31 CEST 2000 |
||||
# |
||||
postgresql.con.auth:L'autenticazione di tipo {0} non è supportata. Verificare che nel file di configurazione pg_hba.conf sia presente l'indirizzo IP o la sotto-rete del client, e che lo schema di autenticazione utilizzato sia supportato dal driver. |
||||
postgresql.con.authfail:Si è verificato un errore durante la richiesta di autenticazione. |
||||
postgresql.con.call:I ``Callable Statements'' non sono supportati al momento. |
||||
postgresql.con.creobj:Fallita la creazione dell'oggetto per {0} {1} |
||||
postgresql.con.failed:Il tentativo di connessione è fallito perché {0} |
||||
#postgresql.con.fathom:Unable to fathom update count {0} |
||||
postgresql.con.garbled:Ricevuti dati incomprensibili. |
||||
postgresql.con.ioerror:Si è verificato un errore di I/O nella spedizione di dati al backend - {0} |
||||
postgresql.con.kerb4:L'autenticazione di tipo ``Kerberos 4'' non è supportata da questo driver. |
||||
postgresql.con.kerb5:L'autenticazione di tipo ``Kerberos 5'' non è supportata da questo driver. |
||||
postgresql.con.multres:Impossibile gestire gruppi multipli di risultati. |
||||
postgresql.con.pass:La proprietà ``password'' è mancante. E` obbligatoria. |
||||
postgresql.con.refused:Connessione rifiutata. Controllare che il nome dell'host e la porta siano corretti, e che il server (postmaster) è in esecuzione con l'opzione -i, che abilita le connessioni attraverso la rete TCP/IP. |
||||
postgresql.con.setup:Errore di protocollo. Fallita l'impostazione della sessione. |
||||
postgresql.con.strobj:L'oggetto potrebbe non essere stato memorizzato. Controllare che ogni tabella richiesta è stata creata nel database. |
||||
postgresql.con.strobjex:Fallita la memorizzazione dell'oggetto - {0} |
||||
postgresql.con.toolong:L'istruzione SQL è troppo lunga - {0} |
||||
postgresql.con.isolevel:Il livello d'isolamento delle transazioni {0} non è supportato. |
||||
postgresql.con.tuple:Tupla ricevuta prima del MetaData. |
||||
postgresql.con.type:Tipo di risposta sconosciuta {0} |
||||
postgresql.con.user:La proprietà ``user'' è mancante. E` obbligatoria. |
||||
postgresql.fp.error:La chiamata a FastPath ha restituito {0} |
||||
postgresql.fp.expint:Chiamata Fastpath {0} - Nessun risultato restituito mentre ci si aspettava un intero. |
||||
postgresql.fp.protocol:Errore nel protocollo FastPath: {0} |
||||
postgresql.fp.send:Fallita la spedizione della chiamata fastpath {0} {1} |
||||
postgresql.fp.unknown:La funzione fastpath {0} è sconosciuta. |
||||
postgresql.geo.box:Fallita la conversione di un ``box'' - {0} |
||||
postgresql.geo.circle:Fallita la conversione di un ``circle'' - {0} |
||||
postgresql.geo.line:Fallita la conversione di una ``line'' - {0} |
||||
postgresql.geo.lseg:Fallita la conversione di un ``lseg'' - {0} |
||||
postgresql.geo.path:Impossibile stabilire se il ``path'' è aperto o chiuso. |
||||
postgresql.geo.point:Fallita la conversione di un ``point'' - {0} |
||||
postgresql.jvm.version:Il file ``postgresql.jar'' non contiene le classi JDBC corrette per questa JVM. Provare a ricompilarle. Se il problema persiste, tentare di forzare la versione fornendola nella linea di comando con l'opzione -Djava.version=1.1 or -Djava.version=1.2\nL'eccezione ricevuta è stata {0} |
||||
postgresql.lo.init:Inizializzazione di LargeObject API fallita. |
||||
postgresql.money:Fallita la conversione di un ``money'' - {0}. |
||||
postgresql.prep.is:InputStream come parametro non è supportato |
||||
postgresql.prep.param:Nessun valore specificato come parametro {0}. |
||||
postgresql.prep.range:Indice di parametro fuori dall'intervallo. |
||||
postgresql.prep.type:Valore di tipo sconosciuto. |
||||
postgresql.res.badbigdec:Cattivo BigDecimal {0} |
||||
postgresql.res.badbyte:Cattivo Byte {0} |
||||
postgresql.res.baddate:Cattivo Date Format a {0} in {1} |
||||
postgresql.res.baddouble:Cattivo Double {0} |
||||
postgresql.res.badfloat:Cattivo Float {0} |
||||
postgresql.res.badint:Cattivo Integer {0} |
||||
postgresql.res.badlong:Cattivo Long {0} |
||||
postgresql.res.badshort:Cattivo Short {0} |
||||
postgresql.res.badtime:Cattivo Time {0} |
||||
postgresql.res.badtimestamp:Cattivo Timestamp Format a {0} in {1} |
||||
postgresql.res.colname:Colonna denominata {0} non trovata. |
||||
postgresql.res.colrange:Indice di colonna fuori dall'intervallo. |
||||
postgresql.serial.interface:Impossibile serializzare una interfaccia. |
||||
postgresql.serial.namelength:La lunghezza dei nomi per Class & Package non può essere superiore a 32 caratteri. {0} è di {1} caratteri. |
||||
postgresql.serial.noclass:Nessuna classe trovata per {0}. |
||||
postgresql.serial.table:La tabella per {0} non è nel database. Contattare il DBA, visto che il database è in uno stato incosistente. |
||||
postgresql.serial.underscore:Il nome di una classe non può contenere il carattere ``_''. E` stato fornito {0}. |
||||
postgresql.stat.batch.empty:La sequenza di operazioni è vuota. Non c'è niente da eseguire. |
||||
postgresql.stat.batch.error:L'operazione {0} {1} della sequenza è stata annullata. |
||||
postgresql.stat.maxfieldsize:Fallito un tentativo a setMaxFieldSize() - verrà utilizzato il valore predefinito a tempo di compilazione. |
||||
postgresql.stat.noresult:Nessun risultato è stato restituito dalla query. |
||||
postgresql.stat.result:Un risultato è stato restituito dallo statement, quando ci si aspettava nulla. |
||||
postgresql.stream.eof:Il backend ha interrotto la connessione. Probabilmente la tua azione ha causato la sua uscita. |
||||
postgresql.stream.flush:Si è verificato un errore di I/O mentre si svuotava il buffer d'uscita - {0} |
||||
postgresql.stream.ioerror:Si è verificato un errore di I/O mentre si leggevano dati dal backend - {0} |
||||
postgresql.stream.toomuch:Troppi dati ricevuti. |
||||
postgresql.unusual:Qualcosa di insolito si è verificato causando il fallimento del driver. Per favore riferire allo sviluppatore questa eccezione: {0} |
||||
postgresql.unimplemented:Questo metodo non è stato ancora implementato. |
||||
postgresql.unexpected:Un risultato inaspettato è stato ricevuto dalla query. |
||||
@ -0,0 +1,68 @@ |
||||
package utils; |
||||
|
||||
/** |
||||
* This little app checks to see what version of JVM is being used. |
||||
* It does this by checking first the java.vm.version property, and |
||||
* if that fails, it looks for certain classes that should be present. |
||||
*/ |
||||
public class CheckVersion |
||||
{ |
||||
/** |
||||
* Check for the existence of a class by attempting to load it |
||||
*/ |
||||
public static boolean checkClass(String c) { |
||||
try { |
||||
Class.forName(c); |
||||
} catch(Exception e) { |
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
/** |
||||
* This first checks java.vm.version for 1.1, 1.2 or 1.3. |
||||
* |
||||
* It writes jdbc1 to stdout for the 1.1.x VM. |
||||
* |
||||
* For 1.2 or 1.3, it checks for the existence of the javax.sql.DataSource |
||||
* interface, and if found writes enterprise to stdout. If the interface
|
||||
* is not found, it writes jdbc2 to stdout. |
||||
* |
||||
* PS: It also looks for the existence of java.lang.Byte which appeared in |
||||
* JDK1.1.0 incase java.vm.version is not heeded by some JVM's. |
||||
* |
||||
* If it can't work it out, it writes huho to stdout. |
||||
* |
||||
* The make file uses the written results to determine which rule to run. |
||||
* |
||||
* Bugs: This needs thorough testing. |
||||
*/ |
||||
public static void main(String args[]) |
||||
{ |
||||
String vmversion = System.getProperty("java.vm.version"); |
||||
|
||||
// We are running a 1.1 JVM
|
||||
if(vmversion.startsWith("1.1")) { |
||||
System.out.println("jdbc1"); |
||||
System.exit(0); |
||||
} |
||||
|
||||
// We are running a 1.2 or 1.3 JVM
|
||||
if(vmversion.startsWith("1.2") || |
||||
vmversion.startsWith("1.3") || |
||||
checkClass("java.lang.Byte") |
||||
) { |
||||
|
||||
// Check to see if we have the standard extensions. If so, then
|
||||
// we want the enterprise edition, otherwise the jdbc2 driver.
|
||||
if(checkClass("javax.sql.DataSource")) |
||||
System.out.println("enterprise"); |
||||
else |
||||
System.out.println("jdbc2"); |
||||
System.exit(0); |
||||
} |
||||
|
||||
System.out.println("huho"); |
||||
System.exit(0); |
||||
} |
||||
} |
||||
@ -0,0 +1,47 @@ |
||||
#!/bin/sh |
||||
# |
||||
# $Id: buildDriver,v 1.1 2000/10/12 08:55:28 peter Exp $ |
||||
# |
||||
# This script generates the org/postgresql/Driver.java file from the template |
||||
# org/postgresql/Driver.java.in |
||||
# |
||||
# We do this because we need to include the version number from Makefile.global |
||||
# and some other goodies. |
||||
# |
||||
# This used to be in Makefile, but as it's now done three times, it's better |
||||
# to have it as a separate script. |
||||
# |
||||
# If you have any problems, please let us know ;-) |
||||
# |
||||
# Syntax: buildDriver version class |
||||
# |
||||
# Where: |
||||
# version The version string from Makefile.global |
||||
# class The class implementing java.sql.Connection |
||||
# edition The driver edition being built |
||||
# source The file to build. We assume that ${source}.in exists |
||||
# |
||||
|
||||
VERSION=$1 |
||||
CLASS=$2 |
||||
EDITION=$3 |
||||
SOURCE=$4 |
||||
|
||||
#--------------------------------------------------------------------------- |
||||
# Extract the version. This will work until version x.9 (and assuming we don't |
||||
# have 7.10 etc). We only handle 1 digit for MINORVERSION to handle things like |
||||
# 7.1devel etc |
||||
# |
||||
MAJORVERSION=`echo $VERSION | cut -f1 -d'.'` |
||||
MINORVERSION=`echo $VERSION | cut -f2 -d'.' | cut -c1` |
||||
|
||||
#--------------------------------------------------------------------------- |
||||
# Now finally build the driver |
||||
sed \ |
||||
-e "s/%JDBCCONNECTCLASS%/$CLASS/g" \ |
||||
-e "s/%VERSION%/$VERSION $EDITION/g" \ |
||||
-e "s/%MAJORVERSION%/$MAJORVERSION/g" \ |
||||
-e "s/%MINORVERSION%/$MINORVERSION/g" \ |
||||
<${SOURCE}.in \ |
||||
>$SOURCE |
||||
#--------------------------------------------------------------------------- |
||||
@ -0,0 +1,23 @@ |
||||
#!/bin/perl |
||||
|
||||
while(<>) { |
||||
chomp(); |
||||
s/\t+/ /g; |
||||
if(substr($_,0,3) eq ' - ') { |
||||
print "<ul>" if !$inlist; |
||||
$inlist=1; |
||||
print "<li>".substr($_,3)."\n"; |
||||
} else { |
||||
if($_ eq "" || $_ eq " ") { |
||||
print "</ul>" if $inlist; |
||||
$inlist=0; |
||||
print "<br>\n"; |
||||
} elsif(substr($_,0,1) eq " ") { |
||||
print $_; |
||||
} else { |
||||
print "</ul>" if $inlist; |
||||
$inlist=0; |
||||
print "<h4>".$_."</h4>\n"; |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue