+Tue Oct 10 13:12:00 BST 2000 peter@retep.org.uk
+ - DatabaseMetaData.supportsAlterTableWithDropColumn() as psql doesn't
+ support dropping of individual columns
+ - Merged in some last patches. Only 1 left, which may not be compatible
+ with jdbc1
+ - Merged in my old retepsql project. Makefile now includes it.
+
+Mon Oct 02 12:30:00 BST 2000 peter@retep.org.uk
+ - Merged in byte[] array allocation changes submitted by Gunnar R|nning
+ <gunnar@candleweb.no>
+
+Mon Sep 25 14:22:00 BST 2000 peter@retep.org.uk
+ - Removed the DriverClass kludge. Now the org.postgresql.Driver class
+ is compiled from a template file, and now has both the connection
+ class (ie jdbc1/jdbc2) and the current version's from Makefile.global
+ -
+
Thu Jul 20 16:30:00 BST 2000 petermount@it.maidstone.gov.uk
- Fixed DatabaseMetaData.getTableTypes()
# Makefile for Java JDBC interface
#
# IDENTIFICATION
-# $Id: Makefile,v 1.24 2000/09/12 04:58:46 momjian Exp $
+# $Id: Makefile,v 1.25 2000/10/12 08:55:23 peter Exp $
#
#-------------------------------------------------------------------------
+subdir = src/interfaces
+top_builddir = ../../..
+include $(top_builddir)/src/Makefile.global
+
+CP = cp
FIND = find
IDL2JAVA = idltojava -fno-cpp -fno-tie
JAR = jar
RM = rm -f
TOUCH = touch
+BUILDDRIVER = sh utils/buildDriver
+CHANGELOG = perl utils/changelog.pl
+
# This defines how to compile a java class
.java.class:
$(JAVAC) $<
# postgresql to org/postgresql
PGBASE = org/postgresql
+# New for 7.1: The jar filename
+JARFILE = postgresql.jar
+
+# Yet another attempt to check the version. In theory, any JVM that fails
+# this is breaking the versioning specifications released by Javasoft.
+#
+all: utils/CheckVersion.class
+ @$(MAKE) `$(JAVA) utils.CheckVersion`
+
# For 6.5.3 and 7.0+, we need to select the correct JDBC API, so prompt
# for the version.
-all:
+huho:
@echo ------------------------------------------------------------
@echo Due to problems with some JVMs that dont return a meaningful
@echo version number, we have had to make the choice of what jdbc
@echo
@echo If you are using JDK1.1.x, you will need the JDBC1.2 driver.
@echo To compile, type:
- @echo " make jdbc1 jar"
+ @echo " make jdbc1"
@echo
@echo "If you are using JDK1.2 (aka Java2) you need the JDBC2."
@echo To compile, type:
- @echo " make jdbc2 jar"
+ @echo " make jdbc2"
+ @echo
+ @echo "If you are using the Java2 Enterprise Edition, you can use"
+ @echo "either the standard driver above, or compile the standard"
+ @echo "extensions version of the driver. Type:"
+ @echo " make enterprise"
@echo
@echo Once you have done this, a postgresql.jar file will be
@echo produced. This file will only work with that particular
- @echo JVM.
+ @echo version of virtual machine.
@echo
@echo ------------------------------------------------------------
@echo
@echo "To make the tests, type:"
@echo " make tests"
+ @echo
+ @echo "To build the GUI Shell, type:"
+ @echo " make retepsql"
+ @echo
@echo ------------------------------------------------------------
@echo
# the jar file.
OBJ_COMMON= $(PGBASE)/Connection.class \
$(PGBASE)/Driver.class \
- $(PGBASE)/DriverClass.class \
$(PGBASE)/Field.class \
$(PGBASE)/PG_Stream.class \
$(PGBASE)/ResultSet.class \
$(PGBASE)/jdbc2/Statement.class \
$(PGBASE)/largeobject/PGblob.class
+# These files are unique to the JDBC2 Enterprise driver
+OBJ_ENTER= $(OBJ_JDBC2) \
+ $(PGBASE)/PostgresqlDataSource.class \
+ $(PGBASE)/xa/ClientConnection.class \
+ $(PGBASE)/xa/TwoPhaseConnection.class \
+ $(PGBASE)/xa/TxConnection.class \
+ $(PGBASE)/xa/XAConnectionImpl.class \
+ $(PGBASE)/xa/XADataSourceImpl.class
+
# This rule builds the JDBC1 compliant driver
jdbc1:
- (echo "package org.postgresql;" ;\
- echo "public class DriverClass {" ;\
- echo "public static String connectClass=\"org.postgresql.jdbc1.Connection\";" ;\
- echo "}" \
- ) >$(PGBASE)/DriverClass.java
+ $(BUILDDRIVER) $(VERSION) org.postgresql.jdbc1.Connection JDBC1.1 $(PGBASE)/Driver.java
-$(RM) postgresql.jar
@$(MAKE) jdbc1real
# This rule does the real work for JDBC1.2, however do not call it directly.
# This is because the JDBC driver relies on the org.postgresql.DriverClass
# class to determine the driver version.
-jdbc1real: $(PGBASE)/DriverClass.class \
- $(OBJ_COMMON) $(OBJ_JDBC1) postgresql.jar msg
+jdbc1real: $(OBJ_COMMON) $(OBJ_JDBC1) $(JARFILE) msg
# This rule builds the JDBC2 compliant driver
-jdbc2:
- (echo "package org.postgresql;" ;\
- echo "public class DriverClass {" ;\
- echo "public static String connectClass=\"org.postgresql.jdbc2.Connection\";" ;\
- echo "}" \
- ) >$(PGBASE)/DriverClass.java
+jdbc2:
+ @$(MAKE) jdbc2internal msg
+
+# This allows us to build the jdbc2 driver without displaying the msg
+# refer to the retepsql rule to see why.
+jdbc2internal:
+ $(BUILDDRIVER) $(VERSION) org.postgresql.jdbc2.Connection Java2 $(PGBASE)/Driver.java
-$(RM) postgresql.jar
@$(MAKE) jdbc2real
# This rule does the real work for JDBC2, however do not call it directly.
# This is because the JDBC driver relies on the org.postgresql.DriverClass
# class to determine the driver version.
-jdbc2real: $(PGBASE)/DriverClass.class \
- $(OBJ_COMMON) $(OBJ_JDBC2) postgresql.jar msg
+jdbc2real: $(OBJ_COMMON) $(OBJ_JDBC2) $(JARFILE)
+
+# This rule builds the enterprise edition of the driver
+enterprise:
+ $(BUILDDRIVER) $(VERSION) org.postgresql.jdbc2.Connection Enterprise $(PGBASE)/Driver.java
+ -$(RM) postgresql.jar
+ @$(MAKE) enterprisereal
-# If you have problems with this rule, replace the $( ) with ` ` as some
-# shells (mainly sh under Solaris) doesn't recognise $( )
+# This rule does the real work for JDBC2 Enterprise Edition, however do not
+# call it directly. This is because the JDBC driver relies on the
+# org.postgresql.DriverClass class to determine the driver version.
+enterprisereal: $(OBJ_COMMON) $(OBJ_ENTER) $(JARFILE)
+
+# We use the old `cmd` notation here as some older shells (mainly sh under
+# Solaris) don't recognise the newer $(cmd) syntax.
#
-postgresql.jar: $(OBJ) $(OBJ_COMMON)
+$(JARFILE): $(OBJ) $(OBJ_COMMON)
$(JAR) -c0f $@ `$(FIND) $(PGBASE) -name "*.class" -print` \
$(wildcard $(PGBASE)/*.properties)
# This rule removes any temporary and compiled files from the source tree.
+#
clean:
$(FIND) . -name "*~" -exec $(RM) {} \;
$(FIND) . -name "*.class" -exec $(RM) {} \;
- $(FIND) . -name "*.html" -exec $(RM) {} \;
-$(RM) -rf stock example/corba/stock.built
- -$(RM) postgresql.jar org/postgresql/DriverClass.java
+ -$(RM) postgresql.jar org/postgresql/Driver.java
-$(RM) -rf Package-postgresql *output
+ -$(RM) retepsql.jar manifest
+
+# New for 7.1
+install: $(JARFILE)
+ $(CP) $(JARFILE) $(libdir)
+
+# This converts CHANGELOG into an html format - used by peter@retep.org.uk
+# to produce an online version
+changelog: changelog.html
+changelog.html: CHANGELOG
+ $(CHANGELOG) $< >$@
#######################################################################
# This helps make workout what classes are from what source files
# tip: we cant use $(wildcard stock/*.java) in the above rule as a race
# condition occurs, where javac is passed no arguments
#######################################################################
+#
+# JPGSql This isn't really an example, but an entire frontend
+# for PostgreSQL via Java & JDBC.
+#
+# Requirements: Java2 platform (JDK1.2.x or 1.3)
+#
+retepsql: jdbc2internal postgresql.jar
+ -$(RM) retepsql.jar
+ @$(MAKE) retepsql.jar
+ @echo
+ @echo "The retepsql application has now been built. To run, simply"
+ @echo "type:"
+ @echo
+ @echo " java -jar retepsql.jar"
+ @echo
+ @echo "Note: Some operating systems recognise .jar as an executable,"
+ @echo " so on those (and Windows is one of them), you can simply"
+ @echo " double click the jar file to start it."
+
+# All my classes have this prefix
+RETEP= uk/org/retep
+
+# These classes form part of my personal swing library. I have placed these
+# into the public domain, so there are no license issues... enjoy...
+RETEPUTILS= $(RETEP)/swing/SwingApplication.class \
+ $(RETEP)/swing/SwingApplication.class \
+
+# This is my postgresql frontend. As it's never been released before, I've
+# decided not only to publish it under the same licence as the JDBC driver,
+# but also to put it along side the driver. To me it makes sense as it's the
+# best example I have on showing how to use the driver ;-)
+RETEPSQL= $(RETEP)/sql/DBConnection.class \
+ $(RETEP)/sql/RetepSQL.class \
+
+# Some ancilary files which are included in the jar file
+RETEPSQLAUX= $(RETEP)/icons/ \
+
+# The big rule, this builds the jpgsql.jar file which contains the entire
+# application. DONT call this rule directly, but use the retepsql one, as
+# it ensures that jdbc is also compiled first.
+#
+# Note: We include the postgresql.jar contents in this as well. Also the
+# manifest entry MUST be immediately after $@ (note the -m option to jar).
+#
+retepsql.jar: $(RETEPUTILS) \
+ $(RETEPSQL)
+ (echo "Manifest-Version: 1.0"; \
+ echo "Created-By: 1.2 (Sun Microsystems Inc.)"; \
+ echo "Main-Class: uk.org.retep.sql.RetepSQL"; \
+ ) >manifest
+ $(JAR) -c0fm $@ manifest \
+ `$(FIND) $(PGBASE) -name "*.class" -print` \
+ $(wildcard $(PGBASE)/*.properties) \
+ `$(FIND) $(RETEP) -name "*.class" -print` \
+ $(RETEPSQLAUX)
+
+#######################################################################
-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;\r
+\r
+import java.io.*;\r
+import java.sql.*;\r
+import java.text.*;\r
+\r
+/**\r
+ * This example application demonstrates some of the drivers other features\r
+ * by implementing a simple psql replacement in Java.\r
+ *\r
+ */\r
+\r
+public class psql\r
+{\r
+ Connection db; // The connection to the database\r
+ Statement st; // Our statement to run queries with\r
+ DatabaseMetaData dbmd; // This defines the structure of the database\r
+ boolean done = false; // Added by CWJ to permit \q command\r
+ \r
+ public psql(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException\r
+ {\r
+ String url = args[0];\r
+ String usr = args[1];\r
+ String pwd = args[2];\r
+ \r
+ // Load the driver\r
+ Class.forName("org.postgresql.Driver");\r
+ \r
+ // Connect to database\r
+ System.out.println("Connecting to Database URL = " + url);\r
+ db = DriverManager.getConnection(url, usr, pwd);\r
+ \r
+ dbmd = db.getMetaData();\r
+ st = db.createStatement();\r
+ \r
+ // This prints the backend's version\r
+ System.out.println("Connected to "+dbmd.getDatabaseProductName()+" "+dbmd.getDatabaseProductVersion());\r
+ \r
+ System.out.println();\r
+ \r
+ // This provides us the means of reading from stdin\r
+ StreamTokenizer input = new StreamTokenizer(new InputStreamReader(System.in));\r
+ input.resetSyntax();\r
+ input.slashSlashComments(true); // allow // as a comment delimiter\r
+ input.eolIsSignificant(false); // treat eol's as spaces\r
+ input.wordChars(32,126);\r
+ input.whitespaceChars(59,59);\r
+ // input.quoteChar(39); *** CWJ: messes up literals in query string ***\r
+ \r
+ // Now the main loop.\r
+ int tt=0,lineno=1;\r
+ while(tt!=StreamTokenizer.TT_EOF && ! done) { // done added by CWJ to permit \q command\r
+ System.out.print("["+lineno+"] ");\r
+ System.out.flush();\r
+ \r
+ // Here, we trap SQLException so they don't terminate the application\r
+ try {\r
+ if((tt=input.nextToken())==StreamTokenizer.TT_WORD) {\r
+ processLine(input.sval);\r
+ lineno++;\r
+ }\r
+ } catch(SQLException ex) {\r
+ System.out.println(ex.getMessage());\r
+ }\r
+ }\r
+ \r
+ System.out.println("Now closing the connection");\r
+ st.close();\r
+ db.close();\r
+ \r
+ }\r
+ \r
+ /**\r
+ * This processes a statement\r
+ */\r
+ public void processLine(String line) throws SQLException\r
+ {\r
+ if(line.startsWith("\\")) {\r
+ processSlashCommand(line);\r
+ return;\r
+ }\r
+ \r
+ boolean type = st.execute(line);\r
+ boolean loop=true;\r
+ while(loop) {\r
+ if(type) {\r
+ // A ResultSet was returned\r
+ ResultSet rs=st.getResultSet();\r
+ displayResult(rs);\r
+ } else {\r
+ int count = st.getUpdateCount();\r
+ \r
+ if(count==-1) {\r
+ // This indicates nothing left\r
+ loop=false;\r
+ } else {\r
+ // An update count was returned\r
+ System.out.println("Updated "+st.getUpdateCount()+" rows");\r
+ }\r
+ }\r
+ \r
+ if(loop)\r
+ type = st.getMoreResults();\r
+ }\r
+ }\r
+ \r
+ /**\r
+ * This displays a result set.\r
+ * Note: it closes the result once complete.\r
+ */\r
+ public void displayResult(ResultSet rs) throws SQLException\r
+ {\r
+ ResultSetMetaData rsmd = rs.getMetaData();\r
+ \r
+ // Print the result column names\r
+ int cols = rsmd.getColumnCount();\r
+ for(int i=1;i<=cols;i++)\r
+ System.out.print(rsmd.getColumnLabel(i)+(i<cols?"\t":"\n"));\r
+ \r
+ // now the results\r
+ while(rs.next()) {\r
+ for(int i=1;i<=cols;i++) {\r
+ Object o = rs.getObject(i);\r
+ if(rs.wasNull())\r
+ System.out.print("{null}"+(i<cols?"\t":"\n"));\r
+ else\r
+ System.out.print(o.toString()+(i<cols?"\t":"\n"));\r
+ }\r
+ }\r
+ \r
+ // finally close the result set\r
+ rs.close();\r
+ }\r
+ \r
+ /**\r
+ * This process / commands (for now just /d)\r
+ */\r
+ public void processSlashCommand(String line) throws SQLException\r
+ {\r
+ if(line.startsWith("\\d")) {\r
+ \r
+ if(line.startsWith("\\d ")) {\r
+ // Display details about a table\r
+ String table=line.substring(3);\r
+ displayResult(dbmd.getColumns(null,null,table,"%"));\r
+ } else {\r
+ String types[] = null;\r
+ if(line.equals("\\d"))\r
+ types=allUserTables;\r
+ else if(line.equals("\\di"))\r
+ types=usrIndices;\r
+ else if(line.equals("\\dt"))\r
+ types=usrTables;\r
+ else if(line.equals("\\ds"))\r
+ types=usrSequences;\r
+ else if(line.equals("\\dS"))\r
+ types=sysTables;\r
+ else\r
+ throw new SQLException("Unsupported \\d command: "+line);\r
+ \r
+ // Display details about all system tables\r
+ //\r
+ // Note: the first two arguments are ignored. To keep to the spec,\r
+ // you must put null here\r
+ //\r
+ displayResult(dbmd.getTables(null,null,"%",types));\r
+ }\r
+ } else if(line.equals("\\q")) // Added by CWJ to permit \q command\r
+ done = true;\r
+ else\r
+ throw new SQLException("Unsupported \\ command: "+line);\r
+ }\r
+ \r
+ private static final String allUserTables[] = {"TABLE","INDEX","SEQUENCE"};\r
+ private static final String usrIndices[] = {"INDEX"};\r
+ private static final String usrTables[] = {"TABLE"};\r
+ private static final String usrSequences[] = {"SEQUENCE"};\r
+ private static final String sysTables[] = {"SYSTEM TABLE","SYSTEM INDEX"};\r
+ \r
+ /**\r
+ * Display some instructions on how to run the example\r
+ */\r
+ public static void instructions()\r
+ {\r
+ 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");\r
+ 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.");\r
+ System.exit(1);\r
+ }\r
+ \r
+ /**\r
+ * This little lot starts the test\r
+ */\r
+ public static void main(String args[])\r
+ {\r
+ System.out.println("PostgreSQL psql example v6.3 rev 1\n");\r
+ \r
+ if(args.length<3)\r
+ instructions();\r
+ \r
+ // This line outputs debug information to stderr. To enable this, simply\r
+ // add an extra parameter to the command line\r
+ if(args.length>3)\r
+ DriverManager.setLogStream(System.err);\r
+ \r
+ // Now run the tests\r
+ try {\r
+ psql test = new psql(args);\r
+ } catch(Exception ex) {\r
+ System.err.println("Exception caught.\n"+ex);\r
+ ex.printStackTrace();\r
+ }\r
+ }\r
+}\r
// manner. (DateStyles are PostgreSQL's way of handling different methods
// of representing dates in the Date data type.)
PreparedStatement ps = db.prepareStatement("insert into basic1 values (?,?)");
- for(int i=2;i<200;i++) {
+ for(int i=2;i<2000;i++) {
ps.setInt(1,4); // "column a" = 5
ps.setInt(2,i); // "column b" = i
ps.executeUpdate(); // executeUpdate because insert returns no data
// manner. (DateStyles are PostgreSQL's way of handling different methods
// of representing dates in the Date data type.)
PreparedStatement ps = db.prepareStatement("insert into basic2 values (?,?)");
- for(int i=2;i<200;i++) {
+ for(int i=2;i<2000;i++) {
ps.setInt(1,4); // "column a" = 5
ps.setInt(2,i); // "column b" = i
ps.executeUpdate(); // executeUpdate because insert returns no data
import org.postgresql.util.*;
/**
- * $Id: Connection.java,v 1.8 2000/10/09 16:48:16 momjian Exp $
+ * $Id: Connection.java,v 1.9 2000/10/12 08:55:24 peter Exp $
*
* This abstract class is used by org.postgresql.Driver to open either the JDBC1 or
* JDBC2 versions of the Connection class.
// The PID an cancellation key we get from the backend process
public int pid;
public int ckey;
+
+ // This receive_sbuf should be used by the different methods
+ // that call pg_stream.ReceiveString() in this Connection, so
+ // so we avoid uneccesary new allocations.
+ byte receive_sbuf[] = new byte[8192];
/**
* This is called by Class.forName() from within org.postgresql.Driver
// "User authentication failed"
//
throw new SQLException(pg_stream.ReceiveString
- (4096, getEncoding()));
+ (receive_sbuf, 4096, getEncoding()));
case 'R':
// Get the type of request
case 'E':
case 'N':
throw new SQLException(pg_stream.ReceiveString
- (4096, getEncoding()));
+ (receive_sbuf, 4096, getEncoding()));
default:
throw new PSQLException("postgresql.con.setup");
}
break;
case 'E':
case 'N':
- throw new SQLException(pg_stream.ReceiveString(4096));
+ throw new SQLException(pg_stream.ReceiveString(receive_sbuf, 4096, getEncoding()));
default:
throw new PSQLException("postgresql.con.setup");
}
{
// added Oct 7 1998 to give us thread safety.
synchronized(pg_stream) {
+ // Deallocate all resources in the stream associated
+ // with a previous request.
+ // This will let the driver reuse byte arrays that has already
+ // been allocated instead of allocating new ones in order
+ // to gain performance improvements.
+ pg_stream.deallocate();
Field[] fields = null;
Vector tuples = new Vector();
{
pg_stream.SendChar('Q');
buf = sql.getBytes();
- pg_stream.Send(buf);
+ pg_stream.Send(sql.getBytes());
pg_stream.SendChar(0);
pg_stream.flush();
} catch (IOException e) {
{
case 'A': // Asynchronous Notify
pid = pg_stream.ReceiveInteger(4);
- msg = pg_stream.ReceiveString(8192);
+ msg = pg_stream.ReceiveString(receive_sbuf,8192,getEncoding());
break;
case 'B': // Binary Data Transfer
if (fields == null)
tuples.addElement(tup);
break;
case 'C': // Command Status
- recv_status = pg_stream.ReceiveString(8192);
+ recv_status = pg_stream.ReceiveString(receive_sbuf,8192,getEncoding());
// Now handle the update count correctly.
if(recv_status.startsWith("INSERT") || recv_status.startsWith("UPDATE") || recv_status.startsWith("DELETE")) {
tuples.addElement(tup);
break;
case 'E': // Error Message
- msg = pg_stream.ReceiveString(4096);
+ msg = pg_stream.ReceiveString(receive_sbuf,4096,getEncoding());
final_error = new SQLException(msg);
hfr = true;
break;
hfr = true;
break;
case 'N': // Error Notification
- addWarning(pg_stream.ReceiveString(4096));
+ addWarning(pg_stream.ReceiveString(receive_sbuf,4096,getEncoding()));
break;
case 'P': // Portal Name
- String pname = pg_stream.ReceiveString(8192);
+ String pname = pg_stream.ReceiveString(receive_sbuf,8192,getEncoding());
break;
case 'T': // MetaData Field Description
if (fields != null)
for (i = 0 ; i < nf ; ++i)
{
- String typname = pg_stream.ReceiveString(8192);
+ String typname = pg_stream.ReceiveString(receive_sbuf,8192,getEncoding());
int typid = pg_stream.ReceiveIntegerR(4);
int typlen = pg_stream.ReceiveIntegerR(2);
int typmod = pg_stream.ReceiveIntegerR(4);
*/
public class Driver implements java.sql.Driver
{
- // These should be in sync with the backend that the driver was
- // distributed with
- static final int MAJORVERSION = 7;
- static final int MINORVERSION = 0;
static
{
if((props = parseURL(url,info))==null)
return null;
- DriverManager.println("Using "+DriverClass.connectClass);
-
try {
- org.postgresql.Connection con = (org.postgresql.Connection)(Class.forName(DriverClass.connectClass).newInstance());
+ 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) {
*/
public int getMajorVersion()
{
- return MAJORVERSION;
+ return %MAJORVERSION%;
}
/**
*/
public int getMinorVersion()
{
- return MINORVERSION;
+ 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
private InputStream pg_input;
private BufferedOutputStream pg_output;
+ BytePoolDim1 bytePoolDim1 = new BytePoolDim1();
+ BytePoolDim2 bytePoolDim2 = new BytePoolDim2();
+
/**
* Constructor: Connect to the PostgreSQL back end and return
* a stream connection.
*/
public void SendInteger(int val, int siz) throws IOException
{
- byte[] buf = new byte[siz];
+ byte[] buf = bytePoolDim1.allocByte(siz);
while (siz-- > 0)
{
*/
public void SendIntegerReverse(int val, int siz) throws IOException
{
- byte[] buf = new byte[siz];
+ byte[] buf = bytePoolDim1.allocByte(siz);
int p=0;
while (siz-- > 0)
{
return n;
}
- public String ReceiveString(int maxsize) throws SQLException {
- return ReceiveString(maxsize, null);
- }
-
/**
* Receives a null-terminated string from the backend. Maximum of
* maxsiz bytes - if we don't see a null, then we assume something
* has gone wrong.
*
+ * @param maxsiz maximum length of string
+ * @return string from back end
+ * @exception SQLException if an I/O error occurs
+ */
+ public String ReceiveString(int maxsiz) throws SQLException
+ {
+ byte[] rst = bytePoolDim1.allocByte(maxsiz);
+ return ReceiveString(rst, maxsiz, null);
+ }
+
+ /**
+ * Receives a null-terminated string from the backend. Maximum of
+ * maxsiz bytes - if we don't see a null, then we assume something
+ * has gone wrong.
+ *
+ * @param maxsiz maximum length of string
* @param encoding the charset encoding to use.
* @param maxsiz maximum length of string in bytes
* @return string from back end
*/
public String ReceiveString(int maxsiz, String encoding) throws SQLException
{
- byte[] rst = new byte[maxsiz];
+ byte[] rst = bytePoolDim1.allocByte(maxsiz);
+ return ReceiveString(rst, maxsiz, encoding);
+ }
+
+ /**
+ * Receives a null-terminated string from the backend. Maximum of
+ * maxsiz bytes - if we don't see a null, then we assume something
+ * has gone wrong.
+ *
+ * @param rst byte array to read the String into. rst.length must
+ * equal to or greater than maxsize.
+ * @param maxsiz maximum length of string in bytes
+ * @param encoding the charset encoding to use.
+ * @return string from back end
+ * @exception SQLException if an I/O error occurs
+ */
+ public String ReceiveString(byte rst[], int maxsiz, String encoding)
+ throws SQLException
+ {
int s = 0;
try
int c = pg_input.read();
if (c < 0)
throw new PSQLException("postgresql.stream.eof");
- else if (c == 0)
- break;
- else
+ else if (c == 0) {
+ rst[s] = 0;
+ break;
+ } else
rst[s++] = (byte)c;
}
if (s >= maxsiz)
{
int i, bim = (nf + 7)/8;
byte[] bitmask = Receive(bim);
- byte[][] answer = new byte[nf][0];
+ byte[][] answer = bytePoolDim2.allocByte(nf);
int whichbit = 0x80;
int whichbyte = 0;
*/
private byte[] Receive(int siz) throws SQLException
{
- byte[] answer = new byte[siz];
+ byte[] answer = bytePoolDim1.allocByte(siz);
Receive(answer,0,siz);
return answer;
}
pg_input.close();
connection.close();
}
+
+ /**
+ * Deallocate all resources that has been associated with any previous
+ * query.
+ */
+ public void deallocate(){
+ bytePoolDim1.deallocate();
+ bytePoolDim2.deallocate();
+ }
+}
+
+/**
+ * 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.
+ */
+class ObjectPool {
+ int cursize = 0;
+ int maxsize = 16;
+ Object arr[] = new Object[maxsize];
+
+ public void add(Object o){
+ if(cursize >= maxsize){
+ Object newarr[] = new Object[maxsize*2];
+ System.arraycopy(arr, 0, newarr, 0, maxsize);
+ maxsize = maxsize * 2;
+ arr = newarr;
+ }
+ arr[cursize++] = o;
+ }
+
+ public Object remove(){
+ return arr[--cursize];
+ }
+ public boolean isEmpty(){
+ return cursize == 0;
+ }
+ public int size(){
+ return cursize;
+ }
+ public void addAll(ObjectPool pool){
+ int srcsize = pool.size();
+ if(srcsize == 0)
+ return;
+ int totalsize = srcsize + cursize;
+ if(totalsize > maxsize){
+ Object newarr[] = new Object[totalsize*2];
+ System.arraycopy(arr, 0, newarr, 0, cursize);
+ maxsize = maxsize = totalsize * 2;
+ arr = newarr;
+ }
+ System.arraycopy(pool.arr, 0, arr, cursize, srcsize);
+ cursize = totalsize;
+ }
+ public void clear(){
+ cursize = 0;
+ }
}
+
+/**
+ * A simple and efficient class to pool one dimensional byte arrays
+ * of different sizes.
+ */
+class BytePoolDim1 {
+ int maxsize = 256;
+ ObjectPool notusemap[] = new ObjectPool[maxsize];
+ ObjectPool inusemap[] = new ObjectPool[maxsize];
+ byte binit[][] = new byte[maxsize][0];
+
+ public BytePoolDim1(){
+ for(int i = 0; i < maxsize; i++){
+ binit[i] = new byte[i];
+ inusemap[i] = new ObjectPool();
+ notusemap[i] = new ObjectPool();
+ }
+ }
+
+ public byte[] allocByte(int size){
+ if(size > maxsize){
+ return new byte[size];
+ }
+
+ ObjectPool not_usel = notusemap[size];
+ ObjectPool in_usel = inusemap[size];
+ byte b[] = null;
+
+ if(!not_usel.isEmpty()) {
+ Object o = not_usel.remove();
+ b = (byte[]) o;
+ } else
+ b = new byte[size];
+ in_usel.add(b);
+
+ return b;
+ }
+
+ public void deallocate(){
+ for(int i = 0; i < maxsize; i++){
+ notusemap[i].addAll(inusemap[i]);
+ inusemap[i].clear();
+ }
+
+ }
+}
+
+
+
+/**
+ * A simple and efficient class to pool two dimensional byte arrays
+ * of different sizes.
+ */
+class BytePoolDim2 {
+ int maxsize = 32;
+ ObjectPool notusemap[] = new ObjectPool[maxsize];
+ ObjectPool inusemap[] = new ObjectPool[maxsize];
+
+ public BytePoolDim2(){
+ for(int i = 0; i < maxsize; i++){
+ inusemap[i] = new ObjectPool();
+ notusemap[i] = new ObjectPool();
+ }
+ }
+
+ public byte[][] allocByte(int size){
+ if(size > maxsize){
+ return new byte[size][0];
+ }
+ ObjectPool not_usel = notusemap[size];
+ ObjectPool in_usel = inusemap[size];
+
+ byte b[][] = null;
+
+ if(!not_usel.isEmpty()) {
+ Object o = not_usel.remove();
+ b = (byte[][]) o;
+ } else
+ b = new byte[size][0];
+ in_usel.add(b);
+ return b;
+ }
+
+ public void deallocate(){
+ for(int i = 0; i < maxsize; i++){
+ notusemap[i].addAll(inusemap[i]);
+ inusemap[i].clear();
+ }
+ }
+}
+
--- /dev/null
+/**
+ * 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;
+ }
+
+
+}
+
# This is the default errors
+postgresql.drv.version:An internal error has occured. Please recompile the driver.
postgresql.con.auth:The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client's IP address or Subnet, and that it is using an authentication scheme supported by the driver.
postgresql.con.authfail:An error occured while getting the authentication request.
postgresql.con.call:Callable Statements are not supported at this time.
--- /dev/null
+# 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.
*/
public String getDatabaseProductVersion() throws SQLException
{
- return ("7.0.2");
+ return connection.this_driver.getVersion();
}
/**
*/
public String getDriverVersion() throws SQLException
{
- return Integer.toString(connection.this_driver.getMajorVersion())+"."+Integer.toString(connection.this_driver.getMinorVersion());
+ return connection.this_driver.getVersion();
}
/**
/**
* Is "ALTER TABLE" with a drop column supported?
- * Yes for PostgreSQL 6.1
+ * Peter 10/10/2000 This was set to true, but 7.1devel doesn't support it!
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsAlterTableWithDropColumn() throws SQLException
{
- return true;
+ return false;
}
/**
*/
public String getDatabaseProductVersion() throws SQLException
{
- return ("7.0.2");
+ return connection.this_driver.getVersion();
}
/**
*/
public String getDriverVersion() throws SQLException
{
- return Integer.toString(connection.this_driver.getMajorVersion())+"."+Integer.toString(connection.this_driver.getMinorVersion());
+ return connection.this_driver.getVersion();
}
/**
/**
* Is "ALTER TABLE" with a drop column supported?
- * Yes for PostgreSQL 6.1
+ * Peter 10/10/2000 This was set to true, but 7.1devel doesn't support it!
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsAlterTableWithDropColumn() throws SQLException
{
- return true;
+ return false;
}
/**
}
/**
- * Are expressions in "ORCER BY" lists supported?
+ * Are expressions in "ORDER BY" lists supported?
*
* <br>e.g. select * from t order by a + b;
*
if (columnIndex < 1 || columnIndex > fields.length)
throw new PSQLException("postgresql.res.colrange");
+
+ wasNullFlag = (this_row[columnIndex - 1] == null);
+ if(wasNullFlag)
+ return null;
+
field = fields[columnIndex - 1];
// some fields can be null, mainly from those returned by MetaData methods
--- /dev/null
+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);
+ }
+}
--- /dev/null
+#!/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
+#---------------------------------------------------------------------------
--- /dev/null
+#!/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";
+ }
+ }
+}
projects / postgresql / commitdiff