From: Bruce Momjian Date: Tue, 13 Feb 2001 16:14:40 +0000 (+0000) Subject: Remove postgresql jdbc files, per Peter Mount. X-Git-Tag: REL7_1~427 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=934c5b841edb9fda9ef3d25196c3adaef6cdb935;p=postgresql Remove postgresql jdbc files, per Peter Mount. --- diff --git a/src/interfaces/jdbc/postgresql/fastpath/Fastpath.java b/src/interfaces/jdbc/postgresql/fastpath/Fastpath.java deleted file mode 100644 index a49dfadc30..0000000000 --- a/src/interfaces/jdbc/postgresql/fastpath/Fastpath.java +++ /dev/null @@ -1,300 +0,0 @@ -package postgresql.fastpath; - -import java.io.*; -import java.lang.*; -import java.net.*; -import java.util.*; -import java.sql.*; -import postgresql.util.*; - -// Important: There are a lot of debug code commented out. Please do not -// delete these. - -/** - * This class implements the Fastpath api. - * - *

This is a means of executing functions imbeded in the postgresql backend - * from within a java application. - * - *

It is based around the file src/interfaces/libpq/fe-exec.c - * - * - *

Implementation notes: - * - *

Network protocol: - * - *

The code within the backend reads integers in reverse. - * - *

There is work in progress to convert all of the protocol to - * network order but it may not be there for v6.3 - * - *

When fastpath switches, simply replace SendIntegerReverse() with - * SendInteger() - * - * @see postgresql.FastpathFastpathArg - * @see postgresql.LargeObject - */ -public class Fastpath -{ - // This maps the functions names to their id's (possible unique just - // to a connection). - protected Hashtable func = new Hashtable(); - - protected postgresql.Connection conn; // our connection - protected postgresql.PG_Stream stream; // the network stream - - /** - * Initialises the fastpath system - * - *

Important Notice - *
This is called from postgresql.Connection, and should not be called - * from client code. - * - * @param conn postgresql.Connection to attach to - * @param stream The network stream to the backend - */ - public Fastpath(postgresql.Connection conn,postgresql.PG_Stream stream) - { - this.conn=conn; - this.stream=stream; - //DriverManager.println("Fastpath initialised"); - } - - /** - * Send a function call to the PostgreSQL backend - * - * @param fnid Function id - * @param resulttype True if the result is an integer, false for other results - * @param args FastpathArguments to pass to fastpath - * @return null if no data, Integer if an integer result, or byte[] otherwise - * @exception SQLException if a database-access error occurs. - */ - public Object fastpath(int fnid,boolean resulttype,FastpathArg[] args) throws SQLException - { - // added Oct 7 1998 to give us thread safety - synchronized(stream) { - - // send the function call - try { - // 70 is 'F' in ASCII. Note: don't use SendChar() here as it adds padding - // that confuses the backend. The 0 terminates the command line. - stream.SendInteger(70,1); - stream.SendInteger(0,1); - - //stream.SendIntegerReverse(fnid,4); - //stream.SendIntegerReverse(args.length,4); - stream.SendInteger(fnid,4); - stream.SendInteger(args.length,4); - - for(int i=0;iUser code should use the addFunctions method, which is based upon a - * query, rather than hard coding the oid. The oid for a function is not - * guaranteed to remain static, even on different servers of the same - * version. - * - * @param name Function name - * @param fnid Function id - */ - public void addFunction(String name,int fnid) - { - func.put(name,new Integer(fnid)); - } - - /** - * This takes a ResultSet containing two columns. Column 1 contains the - * function name, Column 2 the oid. - * - *

It reads the entire ResultSet, loading the values into the function - * table. - * - *

REMEMBER to close() the resultset after calling this!! - * - *

Implementation note about function name lookups: - * - *

PostgreSQL stores the function id's and their corresponding names in - * the pg_proc table. To speed things up locally, instead of querying each - * function from that table when required, a Hashtable is used. Also, only - * the function's required are entered into this table, keeping connection - * times as fast as possible. - * - *

The postgresql.LargeObject class performs a query upon it's startup, - * and passes the returned ResultSet to the addFunctions() method here. - * - *

Once this has been done, the LargeObject api refers to the functions by - * name. - * - *

Dont think that manually converting them to the oid's will work. Ok, - * they will for now, but they can change during development (there was some - * discussion about this for V7.0), so this is implemented to prevent any - * unwarranted headaches in the future. - * - * @param rs ResultSet - * @exception SQLException if a database-access error occurs. - * @see postgresql.LargeObjectManager - */ - public void addFunctions(ResultSet rs) throws SQLException - { - while(rs.next()) { - func.put(rs.getString(1),new Integer(rs.getInt(2))); - } - } - - /** - * This returns the function id associated by its name - * - *

If addFunction() or addFunctions() have not been called for this name, - * then an SQLException is thrown. - * - * @param name Function name to lookup - * @return Function ID for fastpath call - * @exception SQLException is function is unknown. - */ - public int getID(String name) throws SQLException - { - Integer id = (Integer)func.get(name); - - // may be we could add a lookup to the database here, and store the result - // in our lookup table, throwing the exception if that fails. - // We must, however, ensure that if we do, any existing ResultSet is - // unaffected, otherwise we could break user code. - // - // so, until we know we can do this (needs testing, on the TODO list) - // for now, we throw the exception and do no lookups. - if(id==null) - throw new PSQLException("postgresql.fp.unknown",name); - - return id.intValue(); - } -} - diff --git a/src/interfaces/jdbc/postgresql/fastpath/FastpathArg.java b/src/interfaces/jdbc/postgresql/fastpath/FastpathArg.java deleted file mode 100644 index 32c62d761c..0000000000 --- a/src/interfaces/jdbc/postgresql/fastpath/FastpathArg.java +++ /dev/null @@ -1,106 +0,0 @@ -package postgresql.fastpath; - -import java.io.*; -import java.lang.*; -import java.net.*; -import java.util.*; -import java.sql.*; -import postgresql.util.*; - -/** - * Each fastpath call requires an array of arguments, the number and type - * dependent on the function being called. - * - *

This class implements methods needed to provide this capability. - * - *

For an example on how to use this, refer to the postgresql.largeobject - * package - * - * @see postgresql.fastpath.Fastpath - * @see postgresql.largeobject.LargeObjectManager - * @see postgresql.largeobject.LargeObject - */ -public class FastpathArg -{ - /** - * Type of argument, true=integer, false=byte[] - */ - public boolean type; - - /** - * Integer value if type=true - */ - public int value; - - /** - * Byte value if type=false; - */ - public byte[] bytes; - - /** - * Constructs an argument that consists of an integer value - * @param value int value to set - */ - public FastpathArg(int value) - { - type=true; - this.value=value; - } - - /** - * Constructs an argument that consists of an array of bytes - * @param bytes array to store - */ - public FastpathArg(byte bytes[]) - { - type=false; - this.bytes=bytes; - } - - /** - * Constructs an argument that consists of part of a byte array - * @param buf source array - * @param off offset within array - * @param len length of data to include - */ - public FastpathArg(byte buf[],int off,int len) - { - type=false; - bytes = new byte[len]; - System.arraycopy(buf,off,bytes,0,len); - } - - /** - * Constructs an argument that consists of a String. - * @param s String to store - */ - public FastpathArg(String s) - { - this(s.getBytes()); - } - - /** - * This sends this argument down the network stream. - * - *

The stream sent consists of the length.int4 then the contents. - * - *

Note: This is called from Fastpath, and cannot be called from - * client code. - * - * @param s output stream - * @exception IOException if something failed on the network stream - */ - protected void send(postgresql.PG_Stream s) throws IOException - { - if(type) { - // argument is an integer - s.SendInteger(4,4); // size of an integer - s.SendInteger(value,4); // integer value of argument - } else { - // argument is a byte array - s.SendInteger(bytes.length,4); // size of array - s.Send(bytes); - } - } -} - diff --git a/src/interfaces/jdbc/postgresql/geometric/PGbox.java b/src/interfaces/jdbc/postgresql/geometric/PGbox.java deleted file mode 100644 index b8af8df065..0000000000 --- a/src/interfaces/jdbc/postgresql/geometric/PGbox.java +++ /dev/null @@ -1,105 +0,0 @@ -package postgresql.geometric; - -import java.io.*; -import java.sql.*; -import postgresql.util.*; - -/** - * This represents the box datatype within postgresql. - */ -public class PGbox extends PGobject implements Serializable,Cloneable -{ - /** - * These are the two points. - */ - public PGpoint point[] = new PGpoint[2]; - - /** - * @param x1 first x coordinate - * @param y1 first y coordinate - * @param x2 second x coordinate - * @param y2 second y coordinate - */ - public PGbox(double x1,double y1,double x2,double y2) - { - this(); - this.point[0] = new PGpoint(x1,y1); - this.point[1] = new PGpoint(x2,y2); - } - - /** - * @param p1 first point - * @param p2 second point - */ - public PGbox(PGpoint p1,PGpoint p2) - { - this(); - this.point[0] = p1; - this.point[1] = p2; - } - - /** - * @param s Box definition in PostgreSQL syntax - * @exception SQLException if definition is invalid - */ - public PGbox(String s) throws SQLException - { - this(); - setValue(s); - } - - /** - * Required constructor - */ - public PGbox() - { - setType("box"); - } - - /** - * This method sets the value of this object. It should be overidden, - * but still called by subclasses. - * - * @param value a string representation of the value of the object - * @exception SQLException thrown if value is invalid for this type - */ - public void setValue(String value) throws SQLException - { - PGtokenizer t = new PGtokenizer(value,','); - if(t.getSize() != 2) - throw new PSQLException("postgresql.geo.box",value); - - point[0] = new PGpoint(t.getToken(0)); - point[1] = new PGpoint(t.getToken(1)); - } - - /** - * @param obj Object to compare with - * @return true if the two boxes are identical - */ - public boolean equals(Object obj) - { - if(obj instanceof PGbox) { - PGbox p = (PGbox)obj; - return (p.point[0].equals(point[0]) && p.point[1].equals(point[1])) || - (p.point[0].equals(point[1]) && p.point[1].equals(point[0])); - } - return false; - } - - /** - * This must be overidden to allow the object to be cloned - */ - public Object clone() - { - return new PGbox((PGpoint)point[0].clone(),(PGpoint)point[1].clone()); - } - - /** - * @return the PGbox in the syntax expected by postgresql - */ - public String getValue() - { - return point[0].toString()+","+point[1].toString(); - } -} diff --git a/src/interfaces/jdbc/postgresql/geometric/PGcircle.java b/src/interfaces/jdbc/postgresql/geometric/PGcircle.java deleted file mode 100644 index 016e701331..0000000000 --- a/src/interfaces/jdbc/postgresql/geometric/PGcircle.java +++ /dev/null @@ -1,108 +0,0 @@ -package postgresql.geometric; - -import java.io.*; -import java.sql.*; -import postgresql.util.*; - -/** - * This represents postgresql's circle datatype, consisting of a point and - * a radius - */ -public class PGcircle extends PGobject implements Serializable,Cloneable -{ - /** - * This is the centre point - */ - public PGpoint center; - - /** - * This is the radius - */ - double radius; - - /** - * @param x coordinate of centre - * @param y coordinate of centre - * @param r radius of circle - */ - public PGcircle(double x,double y,double r) - { - this(new PGpoint(x,y),r); - } - - /** - * @param c PGpoint describing the circle's centre - * @param r radius of circle - */ - public PGcircle(PGpoint c,double r) - { - this(); - this.center = c; - this.radius = r; - } - - /** - * @param s definition of the circle in PostgreSQL's syntax. - * @exception SQLException on conversion failure - */ - public PGcircle(String s) throws SQLException - { - this(); - setValue(s); - } - - /** - * This constructor is used by the driver. - */ - public PGcircle() - { - setType("circle"); - } - - /** - * @param s definition of the circle in PostgreSQL's syntax. - * @exception SQLException on conversion failure - */ - public void setValue(String s) throws SQLException - { - PGtokenizer t = new PGtokenizer(PGtokenizer.removeAngle(s),','); - if(t.getSize() != 2) - throw new PSQLException("postgresql.geo.circle",s); - - try { - center = new PGpoint(t.getToken(0)); - radius = Double.valueOf(t.getToken(1)).doubleValue(); - } catch(NumberFormatException e) { - throw new PSQLException("postgresql.geo.circle",e); - } - } - - /** - * @param obj Object to compare with - * @return true if the two boxes are identical - */ - public boolean equals(Object obj) - { - if(obj instanceof PGcircle) { - PGcircle p = (PGcircle)obj; - return p.center.equals(center) && p.radius==radius; - } - return false; - } - - /** - * This must be overidden to allow the object to be cloned - */ - public Object clone() - { - return new PGcircle((PGpoint)center.clone(),radius); - } - - /** - * @return the PGcircle in the syntax expected by postgresql - */ - public String getValue() - { - return "<"+center+","+radius+">"; - } -} diff --git a/src/interfaces/jdbc/postgresql/geometric/PGline.java b/src/interfaces/jdbc/postgresql/geometric/PGline.java deleted file mode 100644 index c48867e500..0000000000 --- a/src/interfaces/jdbc/postgresql/geometric/PGline.java +++ /dev/null @@ -1,103 +0,0 @@ -package postgresql.geometric; - -import java.io.*; -import java.sql.*; -import postgresql.util.*; - -/** - * This implements a line consisting of two points. - * - * Currently line is not yet implemented in the backend, but this class - * ensures that when it's done were ready for it. - */ -public class PGline extends PGobject implements Serializable,Cloneable -{ - /** - * These are the two points. - */ - public PGpoint point[] = new PGpoint[2]; - - /** - * @param x1 coordinate for first point - * @param y1 coordinate for first point - * @param x2 coordinate for second point - * @param y2 coordinate for second point - */ - public PGline(double x1,double y1,double x2,double y2) - { - this(new PGpoint(x1,y1),new PGpoint(x2,y2)); - } - - /** - * @param p1 first point - * @param p2 second point - */ - public PGline(PGpoint p1,PGpoint p2) - { - this(); - this.point[0] = p1; - this.point[1] = p2; - } - - /** - * @param s definition of the circle in PostgreSQL's syntax. - * @exception SQLException on conversion failure - */ - public PGline(String s) throws SQLException - { - this(); - setValue(s); - } - - /** - * reuired by the driver - */ - public PGline() - { - setType("line"); - } - - /** - * @param s Definition of the line segment in PostgreSQL's syntax - * @exception SQLException on conversion failure - */ - public void setValue(String s) throws SQLException - { - PGtokenizer t = new PGtokenizer(PGtokenizer.removeBox(s),','); - if(t.getSize() != 2) - throw new PSQLException("postgresql.geo.line",s); - - point[0] = new PGpoint(t.getToken(0)); - point[1] = new PGpoint(t.getToken(1)); - } - - /** - * @param obj Object to compare with - * @return true if the two boxes are identical - */ - public boolean equals(Object obj) - { - if(obj instanceof PGline) { - PGline p = (PGline)obj; - return (p.point[0].equals(point[0]) && p.point[1].equals(point[1])) || - (p.point[0].equals(point[1]) && p.point[1].equals(point[0])); - } - return false; - } - - /** - * This must be overidden to allow the object to be cloned - */ - public Object clone() - { - return new PGline((PGpoint)point[0].clone(),(PGpoint)point[1].clone()); - } - - /** - * @return the PGline in the syntax expected by postgresql - */ - public String getValue() - { - return "["+point[0]+","+point[1]+"]"; - } -} diff --git a/src/interfaces/jdbc/postgresql/geometric/PGlseg.java b/src/interfaces/jdbc/postgresql/geometric/PGlseg.java deleted file mode 100644 index 9fa133e465..0000000000 --- a/src/interfaces/jdbc/postgresql/geometric/PGlseg.java +++ /dev/null @@ -1,100 +0,0 @@ -package postgresql.geometric; - -import java.io.*; -import java.sql.*; -import postgresql.util.*; - -/** - * This implements a lseg (line segment) consisting of two points - */ -public class PGlseg extends PGobject implements Serializable,Cloneable -{ - /** - * These are the two points. - */ - public PGpoint point[] = new PGpoint[2]; - - /** - * @param x1 coordinate for first point - * @param y1 coordinate for first point - * @param x2 coordinate for second point - * @param y2 coordinate for second point - */ - public PGlseg(double x1,double y1,double x2,double y2) - { - this(new PGpoint(x1,y1),new PGpoint(x2,y2)); - } - - /** - * @param p1 first point - * @param p2 second point - */ - public PGlseg(PGpoint p1,PGpoint p2) - { - this(); - this.point[0] = p1; - this.point[1] = p2; - } - - /** - * @param s definition of the circle in PostgreSQL's syntax. - * @exception SQLException on conversion failure - */ - public PGlseg(String s) throws SQLException - { - this(); - setValue(s); - } - - /** - * reuired by the driver - */ - public PGlseg() - { - setType("lseg"); - } - - /** - * @param s Definition of the line segment in PostgreSQL's syntax - * @exception SQLException on conversion failure - */ - public void setValue(String s) throws SQLException - { - PGtokenizer t = new PGtokenizer(PGtokenizer.removeBox(s),','); - if(t.getSize() != 2) - throw new PSQLException("postgresql.geo.lseg"); - - point[0] = new PGpoint(t.getToken(0)); - point[1] = new PGpoint(t.getToken(1)); - } - - /** - * @param obj Object to compare with - * @return true if the two boxes are identical - */ - public boolean equals(Object obj) - { - if(obj instanceof PGlseg) { - PGlseg p = (PGlseg)obj; - return (p.point[0].equals(point[0]) && p.point[1].equals(point[1])) || - (p.point[0].equals(point[1]) && p.point[1].equals(point[0])); - } - return false; - } - - /** - * This must be overidden to allow the object to be cloned - */ - public Object clone() - { - return new PGlseg((PGpoint)point[0].clone(),(PGpoint)point[1].clone()); - } - - /** - * @return the PGlseg in the syntax expected by postgresql - */ - public String getValue() - { - return "["+point[0]+","+point[1]+"]"; - } -} diff --git a/src/interfaces/jdbc/postgresql/geometric/PGpath.java b/src/interfaces/jdbc/postgresql/geometric/PGpath.java deleted file mode 100644 index a5057a661c..0000000000 --- a/src/interfaces/jdbc/postgresql/geometric/PGpath.java +++ /dev/null @@ -1,145 +0,0 @@ -package postgresql.geometric; - -import java.io.*; -import java.sql.*; -import postgresql.util.*; - -/** - * This implements a path (a multiple segmented line, which may be closed) - */ -public class PGpath extends PGobject implements Serializable,Cloneable -{ - /** - * True if the path is open, false if closed - */ - public boolean open; - - /** - * The points defining this path - */ - public PGpoint points[]; - - /** - * @param points the PGpoints that define the path - * @param open True if the path is open, false if closed - */ - public PGpath(PGpoint[] points,boolean open) - { - this(); - this.points = points; - this.open = open; - } - - /** - * Required by the driver - */ - public PGpath() - { - setType("path"); - } - - /** - * @param s definition of the circle in PostgreSQL's syntax. - * @exception SQLException on conversion failure - */ - public PGpath(String s) throws SQLException - { - this(); - setValue(s); - } - - /** - * @param s Definition of the path in PostgreSQL's syntax - * @exception SQLException on conversion failure - */ - public void setValue(String s) throws SQLException - { - // First test to see if were open - if(s.startsWith("[") && s.endsWith("]")) { - open = true; - s = PGtokenizer.removeBox(s); - } else if(s.startsWith("(") && s.endsWith(")")) { - open = false; - s = PGtokenizer.removePara(s); - } else - throw new PSQLException("postgresql.geo.path"); - - PGtokenizer t = new PGtokenizer(s,','); - int npoints = t.getSize(); - points = new PGpoint[npoints]; - for(int p=0;p0) b.append(","); - b.append(points[p].toString()); - } - b.append(open?"]":")"); - - return b.toString(); - } - - public boolean isOpen() - { - return open; - } - - public boolean isClosed() - { - return !open; - } - - public void closePath() - { - open = false; - } - - public void openPath() - { - open = true; - } - -} diff --git a/src/interfaces/jdbc/postgresql/geometric/PGpoint.java b/src/interfaces/jdbc/postgresql/geometric/PGpoint.java deleted file mode 100644 index e06828729a..0000000000 --- a/src/interfaces/jdbc/postgresql/geometric/PGpoint.java +++ /dev/null @@ -1,167 +0,0 @@ -package postgresql.geometric; - -import java.awt.Point; -import java.io.*; -import java.sql.*; - -import postgresql.util.*; - -/** - * This implements a version of java.awt.Point, except it uses double - * to represent the coordinates. - * - *

It maps to the point datatype in postgresql. - */ -public class PGpoint extends PGobject implements Serializable,Cloneable -{ - /** - * The X coordinate of the point - */ - public double x; - - /** - * The Y coordinate of the point - */ - public double y; - - /** - * @param x coordinate - * @param y coordinate - */ - public PGpoint(double x,double y) - { - this(); - this.x = x; - this.y = y; - } - - /** - * This is called mainly from the other geometric types, when a - * point is imbeded within their definition. - * - * @param value Definition of this point in PostgreSQL's syntax - */ - public PGpoint(String value) throws SQLException - { - this(); - setValue(value); - } - - /** - * Required by the driver - */ - public PGpoint() - { - setType("point"); - } - - /** - * @param s Definition of this point in PostgreSQL's syntax - * @exception SQLException on conversion failure - */ - public void setValue(String s) throws SQLException - { - PGtokenizer t = new PGtokenizer(PGtokenizer.removePara(s),','); - try { - x = Double.valueOf(t.getToken(0)).doubleValue(); - y = Double.valueOf(t.getToken(1)).doubleValue(); - } catch(NumberFormatException e) { - throw new PSQLException("postgresql.geo.point",e.toString()); - } - } - - /** - * @param obj Object to compare with - * @return true if the two boxes are identical - */ - public boolean equals(Object obj) - { - if(obj instanceof PGpoint) { - PGpoint p = (PGpoint)obj; - return x == p.x && y == p.y; - } - return false; - } - - /** - * This must be overidden to allow the object to be cloned - */ - public Object clone() - { - return new PGpoint(x,y); - } - - /** - * @return the PGpoint in the syntax expected by postgresql - */ - public String getValue() - { - return "("+x+","+y+")"; - } - - /** - * Translate the point with the supplied amount. - * @param x integer amount to add on the x axis - * @param y integer amount to add on the y axis - */ - public void translate(int x,int y) - { - translate((double)x,(double)y); - } - - /** - * Translate the point with the supplied amount. - * @param x double amount to add on the x axis - * @param y double amount to add on the y axis - */ - public void translate(double x,double y) - { - this.x += x; - this.y += y; - } - - /** - * Moves the point to the supplied coordinates. - * @param x integer coordinate - * @param y integer coordinate - */ - public void move(int x,int y) - { - setLocation(x,y); - } - - /** - * Moves the point to the supplied coordinates. - * @param x double coordinate - * @param y double coordinate - */ - public void move(double x,double y) - { - this.x = x; - this.y = y; - } - - /** - * Moves the point to the supplied coordinates. - * refer to java.awt.Point for description of this - * @param x integer coordinate - * @param y integer coordinate - * @see java.awt.Point - */ - public void setLocation(int x,int y) - { - move((double)x,(double)y); - } - - /** - * Moves the point to the supplied java.awt.Point - * refer to java.awt.Point for description of this - * @param p Point to move to - * @see java.awt.Point - */ - public void setLocation(Point p) - { - setLocation(p.x,p.y); - } - -} diff --git a/src/interfaces/jdbc/postgresql/geometric/PGpolygon.java b/src/interfaces/jdbc/postgresql/geometric/PGpolygon.java deleted file mode 100644 index b60c16e8ce..0000000000 --- a/src/interfaces/jdbc/postgresql/geometric/PGpolygon.java +++ /dev/null @@ -1,105 +0,0 @@ -package postgresql.geometric; - -import java.io.*; -import java.sql.*; -import postgresql.util.*; - -/** - * This implements the polygon datatype within PostgreSQL. - */ -public class PGpolygon extends PGobject implements Serializable,Cloneable -{ - /** - * The points defining the polygon - */ - public PGpoint points[]; - - /** - * Creates a polygon using an array of PGpoints - * - * @param points the points defining the polygon - */ - public PGpolygon(PGpoint[] points) - { - this(); - this.points = points; - } - - /** - * @param s definition of the circle in PostgreSQL's syntax. - * @exception SQLException on conversion failure - */ - public PGpolygon(String s) throws SQLException - { - this(); - setValue(s); - } - - /** - * Required by the driver - */ - public PGpolygon() - { - setType("polygon"); - } - - /** - * @param s Definition of the polygon in PostgreSQL's syntax - * @exception SQLException on conversion failure - */ - public void setValue(String s) throws SQLException - { - PGtokenizer t = new PGtokenizer(PGtokenizer.removePara(s),','); - int npoints = t.getSize(); - points = new PGpoint[npoints]; - for(int p=0;p0) b.append(","); - b.append(points[p].toString()); - } - b.append(")"); - return b.toString(); - } -} diff --git a/src/interfaces/jdbc/postgresql/jdbc1/CallableStatement.java b/src/interfaces/jdbc/postgresql/jdbc1/CallableStatement.java deleted file mode 100644 index 2a90157d01..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc1/CallableStatement.java +++ /dev/null @@ -1,308 +0,0 @@ -package postgresql.jdbc1; - -// IMPORTANT NOTE: This file implements the JDBC 1 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 2 class in the -// postgresql.jdbc2 package. - -import java.sql.*; -import java.math.*; - -/** - * CallableStatement is used to execute SQL stored procedures. - * - *

JDBC provides a stored procedure SQL escape that allows stored - * procedures to be called in a standard way for all RDBMS's. This escape - * syntax has one form that includes a result parameter and one that does - * not. If used, the result parameter must be registered as an OUT - * parameter. The other parameters may be used for input, output or both. - * Parameters are refered to sequentially, by number. The first parameter - * is 1. - * - * {?= call [,, ...]} - * {call [,, ...]} - * - * - *

IN parameter values are set using the set methods inherited from - * PreparedStatement. The type of all OUT parameters must be registered - * prior to executing the stored procedure; their values are retrieved - * after execution via the get methods provided here. - * - *

A Callable statement may return a ResultSet or multiple ResultSets. - * Multiple ResultSets are handled using operations inherited from - * Statement. - * - *

For maximum portability, a call's ResultSets and update counts should - * be processed prior to getting the values of output parameters. - * - * @see Connection#prepareCall - * @see ResultSet - */ - -public class CallableStatement extends PreparedStatement implements java.sql.CallableStatement -{ - /** - * @exception SQLException on failure - */ - CallableStatement(Connection c,String q) throws SQLException - { - super(c,q); - } - - /** - * Before executing a stored procedure call you must explicitly - * call registerOutParameter to register the java.sql.Type of each - * out parameter. - * - *

Note: When reading the value of an out parameter, you must use - * the getXXX method whose Java type XXX corresponds to the - * parameter's registered SQL type. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @param sqlType SQL type code defined by java.sql.Types; for - * parameters of type Numeric or Decimal use the version of - * registerOutParameter that accepts a scale value - * @exception SQLException if a database-access error occurs. - */ - public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException { - } - - /** - * You must also specify the scale for numeric/decimal types: - * - *

Note: When reading the value of an out parameter, you must use - * the getXXX method whose Java type XXX corresponds to the - * parameter's registered SQL type. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @param sqlType use either java.sql.Type.NUMERIC or java.sql.Type.DECIMAL - * @param scale a value greater than or equal to zero representing the - * desired number of digits to the right of the decimal point - * @exception SQLException if a database-access error occurs. - */ - public void registerOutParameter(int parameterIndex, int sqlType, - int scale) throws SQLException - { - } - - // Old api? - //public boolean isNull(int parameterIndex) throws SQLException { - //return true; - //} - - /** - * An OUT parameter may have the value of SQL NULL; wasNull - * reports whether the last value read has this special value. - * - *

Note: You must first call getXXX on a parameter to read its - * value and then call wasNull() to see if the value was SQL NULL. - * @return true if the last parameter read was SQL NULL - * @exception SQLException if a database-access error occurs. - */ - public boolean wasNull() throws SQLException { - // check to see if the last access threw an exception - return false; // fake it for now - } - - // Old api? - //public String getChar(int parameterIndex) throws SQLException { - //return null; - //} - - /** - * Get the value of a CHAR, VARCHAR, or LONGVARCHAR parameter as a - * Java String. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public String getString(int parameterIndex) throws SQLException { - return null; - } - //public String getVarChar(int parameterIndex) throws SQLException { - // return null; - //} - - //public String getLongVarChar(int parameterIndex) throws SQLException { - //return null; - //} - - /** - * Get the value of a BIT parameter as a Java boolean. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is false - * @exception SQLException if a database-access error occurs. - */ - public boolean getBoolean(int parameterIndex) throws SQLException { - return false; - } - - /** - * Get the value of a TINYINT parameter as a Java byte. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public byte getByte(int parameterIndex) throws SQLException { - return 0; - } - - /** - * Get the value of a SMALLINT parameter as a Java short. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public short getShort(int parameterIndex) throws SQLException { - return 0; - } - - /** - * Get the value of an INTEGER parameter as a Java int. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ -public int getInt(int parameterIndex) throws SQLException { - return 0; - } - - /** - * Get the value of a BIGINT parameter as a Java long. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public long getLong(int parameterIndex) throws SQLException { - return 0; - } - - /** - * Get the value of a FLOAT parameter as a Java float. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public float getFloat(int parameterIndex) throws SQLException { - return (float) 0.0; - } - - /** - * Get the value of a DOUBLE parameter as a Java double. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public double getDouble(int parameterIndex) throws SQLException { - return 0.0; - } - - /** - * Get the value of a NUMERIC parameter as a java.math.BigDecimal - * object. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @param scale a value greater than or equal to zero representing the - * desired number of digits to the right of the decimal point - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public BigDecimal getBigDecimal(int parameterIndex, int scale) - throws SQLException { - return null; - } - - /** - * Get the value of a SQL BINARY or VARBINARY parameter as a Java - * byte[] - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public byte[] getBytes(int parameterIndex) throws SQLException { - return null; - } - - // New API (JPM) (getLongVarBinary) - //public byte[] getBinaryStream(int parameterIndex) throws SQLException { - //return null; - //} - - /** - * Get the value of a SQL DATE parameter as a java.sql.Date object - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public java.sql.Date getDate(int parameterIndex) throws SQLException { - return null; - } - - /** - * Get the value of a SQL TIME parameter as a java.sql.Time object. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public java.sql.Time getTime(int parameterIndex) throws SQLException { - return null; - } - - /** - * Get the value of a SQL TIMESTAMP parameter as a java.sql.Timestamp object. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public java.sql.Timestamp getTimestamp(int parameterIndex) - throws SQLException { - return null; - } - - //---------------------------------------------------------------------- - // Advanced features: - - // You can obtain a ParameterMetaData object to get information - // about the parameters to this CallableStatement. - //public DatabaseMetaData getMetaData() { - //return null; - //} - - // getObject returns a Java object for the parameter. - // See the JDBC spec's "Dynamic Programming" chapter for details. - /** - * Get the value of a parameter as a Java object. - * - *

This method returns a Java object whose type coresponds to the - * SQL type that was registered for this parameter using - * registerOutParameter. - * - *

Note that this method may be used to read datatabase-specific, - * abstract data types. This is done by specifying a targetSqlType - * of java.sql.types.OTHER, which allows the driver to return a - * database-specific Java type. - * - *

See the JDBC spec's "Dynamic Programming" chapter for details. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return A java.lang.Object holding the OUT parameter value. - * @exception SQLException if a database-access error occurs. - */ - public Object getObject(int parameterIndex) - throws SQLException { - return null; - } -} - diff --git a/src/interfaces/jdbc/postgresql/jdbc1/Connection.java b/src/interfaces/jdbc/postgresql/jdbc1/Connection.java deleted file mode 100644 index 7a83e6f114..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc1/Connection.java +++ /dev/null @@ -1,389 +0,0 @@ -package postgresql.jdbc1; - -// IMPORTANT NOTE: This file implements the JDBC 1 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 2 class in the -// postgresql.jdbc2 package. - -import java.io.*; -import java.lang.*; -import java.lang.reflect.*; -import java.net.*; -import java.util.*; -import java.sql.*; -import postgresql.Field; -import postgresql.fastpath.*; -import postgresql.largeobject.*; -import postgresql.util.*; - -/** - * $Id: Connection.java,v 1.3 1999/09/14 05:50:39 peter Exp $ - * - * A Connection represents a session with a specific database. Within the - * context of a Connection, SQL statements are executed and results are - * returned. - * - *

A Connection's database is able to provide information describing - * its tables, its supported SQL grammar, its stored procedures, the - * capabilities of this connection, etc. This information is obtained - * with the getMetaData method. - * - *

Note: By default, the Connection automatically commits changes - * after executing each statement. If auto-commit has been disabled, an - * explicit commit must be done or database changes will not be saved. - * - * @see java.sql.Connection - */ -public class Connection extends postgresql.Connection implements java.sql.Connection -{ - // This is a cache of the DatabaseMetaData instance for this connection - protected DatabaseMetaData metadata; - - /** - * SQL statements without parameters are normally executed using - * Statement objects. If the same SQL statement is executed many - * times, it is more efficient to use a PreparedStatement - * - * @return a new Statement object - * @exception SQLException passed through from the constructor - */ - public java.sql.Statement createStatement() throws SQLException - { - return new Statement(this); - } - - /** - * A SQL statement with or without IN parameters can be pre-compiled - * and stored in a PreparedStatement object. This object can then - * be used to efficiently execute this statement multiple times. - * - * Note: This method is optimized for handling parametric - * SQL statements that benefit from precompilation if the drivers - * supports precompilation. PostgreSQL does not support precompilation. - * In this case, the statement is not sent to the database until the - * PreparedStatement is executed. This has no direct effect on users; - * however it does affect which method throws certain SQLExceptions - * - * @param sql a SQL statement that may contain one or more '?' IN - * parameter placeholders - * @return a new PreparedStatement object containing the pre-compiled - * statement. - * @exception SQLException if a database access error occurs. - */ - public java.sql.PreparedStatement prepareStatement(String sql) throws SQLException - { - return new PreparedStatement(this, sql); - } - - /** - * A SQL stored procedure call statement is handled by creating a - * CallableStatement for it. The CallableStatement provides methods - * for setting up its IN and OUT parameters and methods for executing - * it. - * - * Note: This method is optimised for handling stored procedure - * call statements. Some drivers may send the call statement to the - * database when the prepareCall is done; others may wait until the - * CallableStatement is executed. This has no direct effect on users; - * however, it does affect which method throws certain SQLExceptions - * - * @param sql a SQL statement that may contain one or more '?' parameter - * placeholders. Typically this statement is a JDBC function call - * escape string. - * @return a new CallableStatement object containing the pre-compiled - * SQL statement - * @exception SQLException if a database access error occurs - */ - public java.sql.CallableStatement prepareCall(String sql) throws SQLException - { - throw new PSQLException("postgresql.con.call"); - // return new CallableStatement(this, sql); - } - - /** - * A driver may convert the JDBC sql grammar into its system's - * native SQL grammar prior to sending it; nativeSQL returns the - * native form of the statement that the driver would have sent. - * - * @param sql a SQL statement that may contain one or more '?' - * parameter placeholders - * @return the native form of this statement - * @exception SQLException if a database access error occurs - */ - public String nativeSQL(String sql) throws SQLException - { - return sql; - } - - /** - * If a connection is in auto-commit mode, than all its SQL - * statements will be executed and committed as individual - * transactions. Otherwise, its SQL statements are grouped - * into transactions that are terminated by either commit() - * or rollback(). By default, new connections are in auto- - * commit mode. The commit occurs when the statement completes - * or the next execute occurs, whichever comes first. In the - * case of statements returning a ResultSet, the statement - * completes when the last row of the ResultSet has been retrieved - * or the ResultSet has been closed. In advanced cases, a single - * statement may return multiple results as well as output parameter - * values. Here the commit occurs when all results and output param - * values have been retrieved. - * - * @param autoCommit - true enables auto-commit; false disables it - * @exception SQLException if a database access error occurs - */ - public void setAutoCommit(boolean autoCommit) throws SQLException - { - if (this.autoCommit == autoCommit) - return; - if (autoCommit) - ExecSQL("end"); - else - ExecSQL("begin"); - this.autoCommit = autoCommit; - } - - /** - * gets the current auto-commit state - * - * @return Current state of the auto-commit mode - * @exception SQLException (why?) - * @see setAutoCommit - */ - public boolean getAutoCommit() throws SQLException - { - return this.autoCommit; - } - - /** - * The method commit() makes all changes made since the previous - * commit/rollback permanent and releases any database locks currently - * held by the Connection. This method should only be used when - * auto-commit has been disabled. (If autoCommit == true, then we - * just return anyhow) - * - * @exception SQLException if a database access error occurs - * @see setAutoCommit - */ - public void commit() throws SQLException - { - if (autoCommit) - return; - ExecSQL("commit"); - autoCommit = true; - ExecSQL("begin"); - autoCommit = false; - } - - /** - * The method rollback() drops all changes made since the previous - * commit/rollback and releases any database locks currently held by - * the Connection. - * - * @exception SQLException if a database access error occurs - * @see commit - */ - public void rollback() throws SQLException - { - if (autoCommit) - return; - ExecSQL("rollback"); - autoCommit = true; - ExecSQL("begin"); - autoCommit = false; - } - - /** - * In some cases, it is desirable to immediately release a Connection's - * database and JDBC resources instead of waiting for them to be - * automatically released (cant think why off the top of my head) - * - * Note: A Connection is automatically closed when it is - * garbage collected. Certain fatal errors also result in a closed - * connection. - * - * @exception SQLException if a database access error occurs - */ - public void close() throws SQLException - { - if (pg_stream != null) - { - try - { - pg_stream.close(); - } catch (IOException e) {} - pg_stream = null; - } - } - - /** - * Tests to see if a Connection is closed - * - * @return the status of the connection - * @exception SQLException (why?) - */ - public boolean isClosed() throws SQLException - { - return (pg_stream == null); - } - - /** - * A connection's database is able to provide information describing - * its tables, its supported SQL grammar, its stored procedures, the - * capabilities of this connection, etc. This information is made - * available through a DatabaseMetaData object. - * - * @return a DatabaseMetaData object for this connection - * @exception SQLException if a database access error occurs - */ - public java.sql.DatabaseMetaData getMetaData() throws SQLException - { - if(metadata==null) - metadata = new DatabaseMetaData(this); - return metadata; - } - - /** - * You can put a connection in read-only mode as a hunt to enable - * database optimizations - * - * Note: setReadOnly cannot be called while in the middle - * of a transaction - * - * @param readOnly - true enables read-only mode; false disables it - * @exception SQLException if a database access error occurs - */ - public void setReadOnly (boolean readOnly) throws SQLException - { - this.readOnly = readOnly; - } - - /** - * Tests to see if the connection is in Read Only Mode. Note that - * we cannot really put the database in read only mode, but we pretend - * we can by returning the value of the readOnly flag - * - * @return true if the connection is read only - * @exception SQLException if a database access error occurs - */ - public boolean isReadOnly() throws SQLException - { - return readOnly; - } - - /** - * A sub-space of this Connection's database may be selected by - * setting a catalog name. If the driver does not support catalogs, - * it will silently ignore this request - * - * @exception SQLException if a database access error occurs - */ - public void setCatalog(String catalog) throws SQLException - { - // No-op - } - - /** - * Return the connections current catalog name, or null if no - * catalog name is set, or we dont support catalogs. - * - * @return the current catalog name or null - * @exception SQLException if a database access error occurs - */ - public String getCatalog() throws SQLException - { - return null; - } - - /** - * You can call this method to try to change the transaction - * isolation level using one of the TRANSACTION_* values. - * - * Note: setTransactionIsolation cannot be called while - * in the middle of a transaction - * - * @param level one of the TRANSACTION_* isolation values with - * the exception of TRANSACTION_NONE; some databases may - * not support other values - * @exception SQLException if a database access error occurs - * @see java.sql.DatabaseMetaData#supportsTransactionIsolationLevel - */ - public void setTransactionIsolation(int level) throws SQLException - { - String q = "SET TRANSACTION ISOLATION LEVEL"; - - switch(level) { - - case java.sql.Connection.TRANSACTION_READ_COMMITTED: - ExecSQL(q + " READ COMMITTED"); - return; - - case java.sql.Connection.TRANSACTION_SERIALIZABLE: - ExecSQL(q + " SERIALIZABLE"); - return; - - default: - throw new PSQLException("postgresql.con.isolevel",new Integer(level)); - } - } - - /** - * Get this Connection's current transaction isolation mode. - * - * @return the current TRANSACTION_* mode value - * @exception SQLException if a database access error occurs - */ - public int getTransactionIsolation() throws SQLException - { - ExecSQL("show xactisolevel"); - - SQLWarning w = getWarnings(); - if (w != null) { - if (w.getMessage().indexOf("READ COMMITTED") != -1) return java.sql.Connection.TRANSACTION_READ_COMMITTED; else - if (w.getMessage().indexOf("READ UNCOMMITTED") != -1) return java.sql.Connection.TRANSACTION_READ_UNCOMMITTED; else - if (w.getMessage().indexOf("REPEATABLE READ") != -1) return java.sql.Connection.TRANSACTION_REPEATABLE_READ; else - if (w.getMessage().indexOf("SERIALIZABLE") != -1) return java.sql.Connection.TRANSACTION_SERIALIZABLE; - } - return java.sql.Connection.TRANSACTION_READ_COMMITTED; - } - - /** - * The first warning reported by calls on this Connection is - * returned. - * - * Note: Sebsequent warnings will be changed to this - * SQLWarning - * - * @return the first SQLWarning or null - * @exception SQLException if a database access error occurs - */ - public SQLWarning getWarnings() throws SQLException - { - return firstWarning; - } - - /** - * After this call, getWarnings returns null until a new warning - * is reported for this connection. - * - * @exception SQLException if a database access error occurs - */ - public void clearWarnings() throws SQLException - { - firstWarning = null; - } - - /** - * This overides the method in postgresql.Connection and returns a - * ResultSet. - */ - protected java.sql.ResultSet getResultSet(postgresql.Connection conn, Field[] fields, Vector tuples, String status, int updateCount) throws SQLException - { - return new postgresql.jdbc1.ResultSet((postgresql.jdbc1.Connection)conn,fields,tuples,status,updateCount); - } - -} - -// *********************************************************************** - diff --git a/src/interfaces/jdbc/postgresql/jdbc1/DatabaseMetaData.java b/src/interfaces/jdbc/postgresql/jdbc1/DatabaseMetaData.java deleted file mode 100644 index 595340f22f..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc1/DatabaseMetaData.java +++ /dev/null @@ -1,2524 +0,0 @@ -package postgresql.jdbc1; - -// IMPORTANT NOTE: This file implements the JDBC 1 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 2 class in the -// postgresql.jdbc2 package. - -import java.sql.*; -import java.util.*; -import postgresql.Field; - -/** - * This class provides information about the database as a whole. - * - *

Many of the methods here return lists of information in ResultSets. You - * can use the normal ResultSet methods such as getString and getInt to - * retrieve the data from these ResultSets. If a given form of metadata is - * not available, these methods should throw a SQLException. - * - *

Some of these methods take arguments that are String patterns. These - * arguments all have names such as fooPattern. Within a pattern String, - * "%" means match any substring of 0 or more characters, and "_" means - * match any one character. Only metadata entries matching the search - * pattern are returned. if a search pattern argument is set to a null - * ref, it means that argument's criteria should be dropped from the - * search. - * - *

A SQLException will be throws if a driver does not support a meta - * data method. In the case of methods that return a ResultSet, either - * a ResultSet (which may be empty) is returned or a SQLException is - * thrown. - * - * @see java.sql.DatabaseMetaData - */ -public class DatabaseMetaData implements java.sql.DatabaseMetaData -{ - Connection connection; // The connection association - - // These define various OID's. Hopefully they will stay constant. - static final int iVarcharOid = 1043; // OID for varchar - static final int iBoolOid = 16; // OID for bool - static final int iInt2Oid = 21; // OID for int2 - static final int iInt4Oid = 23; // OID for int4 - static final int VARHDRSZ = 4; // length for int4 - - // This is a default value for remarks - private static final byte defaultRemarks[]="no remarks".getBytes(); - - public DatabaseMetaData(Connection conn) - { - this.connection = conn; - } - - /** - * Can all the procedures returned by getProcedures be called - * by the current user? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean allProceduresAreCallable() throws SQLException - { - return true; // For now... - } - - /** - * Can all the tables returned by getTable be SELECTed by - * the current user? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean allTablesAreSelectable() throws SQLException - { - return true; // For now... - } - - /** - * What is the URL for this database? - * - * @return the url or null if it cannott be generated - * @exception SQLException if a database access error occurs - */ - public String getURL() throws SQLException - { - return connection.getURL(); - } - - /** - * What is our user name as known to the database? - * - * @return our database user name - * @exception SQLException if a database access error occurs - */ - public String getUserName() throws SQLException - { - return connection.getUserName(); - } - - /** - * Is the database in read-only mode? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isReadOnly() throws SQLException - { - return connection.isReadOnly(); - } - - /** - * Are NULL values sorted high? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullsAreSortedHigh() throws SQLException - { - return false; - } - - /** - * Are NULL values sorted low? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullsAreSortedLow() throws SQLException - { - return false; - } - - /** - * Are NULL values sorted at the start regardless of sort order? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullsAreSortedAtStart() throws SQLException - { - return false; - } - - /** - * Are NULL values sorted at the end regardless of sort order? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullsAreSortedAtEnd() throws SQLException - { - return true; - } - - /** - * What is the name of this database product - we hope that it is - * PostgreSQL, so we return that explicitly. - * - * @return the database product name - * @exception SQLException if a database access error occurs - */ - public String getDatabaseProductName() throws SQLException - { - return new String("PostgreSQL"); - } - - /** - * What is the version of this database product. - * - *

Note that PostgreSQL 6.3 has a system catalog called pg_version - - * however, select * from pg_version on any database retrieves - * no rows. - * - *

For now, we will return the version 6.3 (in the hope that we change - * this driver as often as we change the database) - * - * @return the database version - * @exception SQLException if a database access error occurs - */ - public String getDatabaseProductVersion() throws SQLException - { - return ("7.1"); - } - - /** - * What is the name of this JDBC driver? If we don't know this - * we are doing something wrong! - * - * @return the JDBC driver name - * @exception SQLException why? - */ - public String getDriverName() throws SQLException - { - return new String("PostgreSQL Native Driver"); - } - - /** - * What is the version string of this JDBC driver? Again, this is - * static. - * - * @return the JDBC driver name. - * @exception SQLException why? - */ - public String getDriverVersion() throws SQLException - { - return new String(Integer.toString(connection.this_driver.getMajorVersion())+"."+Integer.toString(connection.this_driver.getMinorVersion())); - } - - /** - * What is this JDBC driver's major version number? - * - * @return the JDBC driver major version - */ - public int getDriverMajorVersion() - { - return connection.this_driver.getMajorVersion(); - } - - /** - * What is this JDBC driver's minor version number? - * - * @return the JDBC driver minor version - */ - public int getDriverMinorVersion() - { - return connection.this_driver.getMinorVersion(); - } - - /** - * Does the database store tables in a local file? No - it - * stores them in a file on the server. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean usesLocalFiles() throws SQLException - { - return false; - } - - /** - * Does the database use a file for each table? Well, not really, - * since it doesnt use local files. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean usesLocalFilePerTable() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case unquoted SQL identifiers - * as case sensitive and as a result store them in mixed case? - * A JDBC-Compliant driver will always return false. - * - *

Predicament - what do they mean by "SQL identifiers" - if it - * means the names of the tables and columns, then the answers - * given below are correct - otherwise I don't know. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMixedCaseIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case unquoted SQL identifiers as - * case insensitive and store them in upper case? - * - * @return true if so - */ - public boolean storesUpperCaseIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case unquoted SQL identifiers as - * case insensitive and store them in lower case? - * - * @return true if so - */ - public boolean storesLowerCaseIdentifiers() throws SQLException - { - return true; - } - - /** - * Does the database treat mixed case unquoted SQL identifiers as - * case insensitive and store them in mixed case? - * - * @return true if so - */ - public boolean storesMixedCaseIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case quoted SQL identifiers as - * case sensitive and as a result store them in mixed case? A - * JDBC compliant driver will always return true. - * - *

Predicament - what do they mean by "SQL identifiers" - if it - * means the names of the tables and columns, then the answers - * given below are correct - otherwise I don't know. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException - { - return true; - } - - /** - * Does the database treat mixed case quoted SQL identifiers as - * case insensitive and store them in upper case? - * - * @return true if so - */ - public boolean storesUpperCaseQuotedIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case quoted SQL identifiers as case - * insensitive and store them in lower case? - * - * @return true if so - */ - public boolean storesLowerCaseQuotedIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case quoted SQL identifiers as case - * insensitive and store them in mixed case? - * - * @return true if so - */ - public boolean storesMixedCaseQuotedIdentifiers() throws SQLException - { - return false; - } - - /** - * What is the string used to quote SQL identifiers? This returns - * a space if identifier quoting isn't supported. A JDBC Compliant - * driver will always use a double quote character. - * - *

If an SQL identifier is a table name, column name, etc. then - * we do not support it. - * - * @return the quoting string - * @exception SQLException if a database access error occurs - */ - public String getIdentifierQuoteString() throws SQLException - { - return null; - } - - /** - * Get a comma separated list of all a database's SQL keywords that - * are NOT also SQL92 keywords. - * - *

Within PostgreSQL, the keywords are found in - * src/backend/parser/keywords.c - * - *

For SQL Keywords, I took the list provided at - * - * http://web.dementia.org/~shadow/sql/sql3bnf.sep93.txt - * which is for SQL3, not SQL-92, but it is close enough for - * this purpose. - * - * @return a comma separated list of keywords we use - * @exception SQLException if a database access error occurs - */ - public String getSQLKeywords() throws SQLException - { - return new String("abort,acl,add,aggregate,append,archive,arch_store,backward,binary,change,cluster,copy,database,delimiters,do,extend,explain,forward,heavy,index,inherits,isnull,light,listen,load,merge,nothing,notify,notnull,oids,purge,rename,replace,retrieve,returns,rule,recipe,setof,stdin,stdout,store,vacuum,verbose,version"); - } - - public String getNumericFunctions() throws SQLException - { - // XXX-Not Implemented - return ""; - } - - public String getStringFunctions() throws SQLException - { - // XXX-Not Implemented - return ""; - } - - public String getSystemFunctions() throws SQLException - { - // XXX-Not Implemented - return ""; - } - - public String getTimeDateFunctions() throws SQLException - { - // XXX-Not Implemented - return ""; - } - - /** - * This is the string that can be used to escape '_' and '%' in - * a search string pattern style catalog search parameters - * - * @return the string used to escape wildcard characters - * @exception SQLException if a database access error occurs - */ - public String getSearchStringEscape() throws SQLException - { - return new String("\\"); - } - - /** - * Get all the "extra" characters that can bew used in unquoted - * identifier names (those beyond a-zA-Z0-9 and _) - * - *

From the file src/backend/parser/scan.l, an identifier is - * {letter}{letter_or_digit} which makes it just those listed - * above. - * - * @return a string containing the extra characters - * @exception SQLException if a database access error occurs - */ - public String getExtraNameCharacters() throws SQLException - { - return new String(""); - } - - /** - * Is "ALTER TABLE" with an add column supported? - * Yes for PostgreSQL 6.1 - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsAlterTableWithAddColumn() throws SQLException - { - return true; - } - - /** - * Is "ALTER TABLE" with a drop column supported? - * Yes for PostgreSQL 6.1 - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsAlterTableWithDropColumn() throws SQLException - { - return true; - } - - /** - * Is column aliasing supported? - * - *

If so, the SQL AS clause can be used to provide names for - * computed columns or to provide alias names for columns as - * required. A JDBC Compliant driver always returns true. - * - *

e.g. - * - * 

-   * select count(C) as C_COUNT from T group by C;
-   *
-   *

- * should return a column named as C_COUNT instead of count(C) - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsColumnAliasing() throws SQLException - { - return true; - } - - /** - * Are concatenations between NULL and non-NULL values NULL? A - * JDBC Compliant driver always returns true - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullPlusNonNullIsNull() throws SQLException - { - return true; - } - - public boolean supportsConvert() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsConvert(int fromType, int toType) throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsTableCorrelationNames() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsDifferentTableCorrelationNames() throws SQLException - { - // XXX-Not Implemented - return false; - } - - /** - * Are expressions in "ORCER BY" lists supported? - * - *
e.g. select * from t order by a + b; - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsExpressionsInOrderBy() throws SQLException - { - return true; - } - - /** - * Can an "ORDER BY" clause use columns not in the SELECT? - * I checked it, and you can't. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsOrderByUnrelated() throws SQLException - { - return false; - } - - /** - * Is some form of "GROUP BY" clause supported? - * I checked it, and yes it is. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsGroupBy() throws SQLException - { - return true; - } - - /** - * Can a "GROUP BY" clause use columns not in the SELECT? - * I checked it - it seems to allow it - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsGroupByUnrelated() throws SQLException - { - return true; - } - - /** - * Can a "GROUP BY" clause add columns not in the SELECT provided - * it specifies all the columns in the SELECT? Does anyone actually - * understand what they mean here? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsGroupByBeyondSelect() throws SQLException - { - return true; // For now... - } - - /** - * Is the escape character in "LIKE" clauses supported? A - * JDBC compliant driver always returns true. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsLikeEscapeClause() throws SQLException - { - return true; - } - - /** - * Are multiple ResultSets from a single execute supported? - * Well, I implemented it, but I dont think this is possible from - * the back ends point of view. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMultipleResultSets() throws SQLException - { - return false; - } - - /** - * Can we have multiple transactions open at once (on different - * connections?) - * I guess we can have, since Im relying on it. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMultipleTransactions() throws SQLException - { - return true; - } - - /** - * Can columns be defined as non-nullable. A JDBC Compliant driver - * always returns true. - * - *

This changed from false to true in v6.2 of the driver, as this - * support was added to the backend. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsNonNullableColumns() throws SQLException - { - return true; - } - - /** - * Does this driver support the minimum ODBC SQL grammar. This - * grammar is defined at: - * - *

http://www.microsoft.com/msdn/sdk/platforms/doc/odbc/src/intropr.htm - * - *

In Appendix C. From this description, we seem to support the - * ODBC minimal (Level 0) grammar. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMinimumSQLGrammar() throws SQLException - { - return true; - } - - /** - * Does this driver support the Core ODBC SQL grammar. We need - * SQL-92 conformance for this. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCoreSQLGrammar() throws SQLException - { - return false; - } - - /** - * Does this driver support the Extended (Level 2) ODBC SQL - * grammar. We don't conform to the Core (Level 1), so we can't - * conform to the Extended SQL Grammar. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsExtendedSQLGrammar() throws SQLException - { - return false; - } - - /** - * Does this driver support the ANSI-92 entry level SQL grammar? - * All JDBC Compliant drivers must return true. I think we have - * to support outer joins for this to be true. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsANSI92EntryLevelSQL() throws SQLException - { - return false; - } - - /** - * Does this driver support the ANSI-92 intermediate level SQL - * grammar? Anyone who does not support Entry level cannot support - * Intermediate level. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsANSI92IntermediateSQL() throws SQLException - { - return false; - } - - /** - * Does this driver support the ANSI-92 full SQL grammar? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsANSI92FullSQL() throws SQLException - { - return false; - } - - /** - * Is the SQL Integrity Enhancement Facility supported? - * I haven't seen this mentioned anywhere, so I guess not - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsIntegrityEnhancementFacility() throws SQLException - { - return false; - } - - /** - * Is some form of outer join supported? From my knowledge, nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsOuterJoins() throws SQLException - { - return false; - } - - /** - * Are full nexted outer joins supported? Well, we dont support any - * form of outer join, so this is no as well - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsFullOuterJoins() throws SQLException - { - return false; - } - - /** - * Is there limited support for outer joins? (This will be true if - * supportFullOuterJoins is true) - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsLimitedOuterJoins() throws SQLException - { - return false; - } - - /** - * What is the database vendor's preferred term for "schema" - well, - * we do not provide support for schemas, so lets just use that - * term. - * - * @return the vendor term - * @exception SQLException if a database access error occurs - */ - public String getSchemaTerm() throws SQLException - { - return new String("Schema"); - } - - /** - * What is the database vendor's preferred term for "procedure" - - * I kind of like "Procedure" myself. - * - * @return the vendor term - * @exception SQLException if a database access error occurs - */ - public String getProcedureTerm() throws SQLException - { - return new String("Procedure"); - } - - /** - * What is the database vendor's preferred term for "catalog"? - - * we dont have a preferred term, so just use Catalog - * - * @return the vendor term - * @exception SQLException if a database access error occurs - */ - public String getCatalogTerm() throws SQLException - { - return new String("Catalog"); - } - - /** - * Does a catalog appear at the start of a qualified table name? - * (Otherwise it appears at the end). - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isCatalogAtStart() throws SQLException - { - return false; - } - - /** - * What is the Catalog separator. Hmmm....well, I kind of like - * a period (so we get catalog.table definitions). - I don't think - * PostgreSQL supports catalogs anyhow, so it makes no difference. - * - * @return the catalog separator string - * @exception SQLException if a database access error occurs - */ - public String getCatalogSeparator() throws SQLException - { - // PM Sep 29 97 - changed from "." as we don't support catalogs. - return new String(""); - } - - /** - * Can a schema name be used in a data manipulation statement? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInDataManipulation() throws SQLException - { - return false; - } - - /** - * Can a schema name be used in a procedure call statement? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInProcedureCalls() throws SQLException - { - return false; - } - - /** - * Can a schema be used in a table definition statement? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInTableDefinitions() throws SQLException - { - return false; - } - - /** - * Can a schema name be used in an index definition statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInIndexDefinitions() throws SQLException - { - return false; - } - - /** - * Can a schema name be used in a privilege definition statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in a data manipulation statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInDataManipulation() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in a procedure call statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInProcedureCalls() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in a table definition statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInTableDefinitions() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in an index definition? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInIndexDefinitions() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in a privilege definition statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException - { - return false; - } - - /** - * We support cursors for gets only it seems. I dont see a method - * to get a positioned delete. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsPositionedDelete() throws SQLException - { - return false; // For now... - } - - /** - * Is positioned UPDATE supported? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsPositionedUpdate() throws SQLException - { - return false; // For now... - } - - public boolean supportsSelectForUpdate() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsStoredProcedures() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsSubqueriesInComparisons() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsSubqueriesInExists() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsSubqueriesInIns() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsSubqueriesInQuantifieds() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsCorrelatedSubqueries() throws SQLException - { - // XXX-Not Implemented - return false; - } - - /** - * Is SQL UNION supported? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsUnion() throws SQLException - { - return false; - } - - /** - * Is SQL UNION ALL supported? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsUnionAll() throws SQLException - { - return false; - } - - /** - * In PostgreSQL, Cursors are only open within transactions. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsOpenCursorsAcrossCommit() throws SQLException - { - return false; - } - - /** - * Do we support open cursors across multiple transactions? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsOpenCursorsAcrossRollback() throws SQLException - { - return false; - } - - /** - * Can statements remain open across commits? They may, but - * this driver cannot guarentee that. In further reflection. - * we are talking a Statement object jere, so the answer is - * yes, since the Statement is only a vehicle to ExecSQL() - * - * @return true if they always remain open; false otherwise - * @exception SQLException if a database access error occurs - */ - public boolean supportsOpenStatementsAcrossCommit() throws SQLException - { - return true; - } - - /** - * Can statements remain open across rollbacks? They may, but - * this driver cannot guarentee that. In further contemplation, - * we are talking a Statement object here, so the answer is yes, - * since the Statement is only a vehicle to ExecSQL() in Connection - * - * @return true if they always remain open; false otherwise - * @exception SQLException if a database access error occurs - */ - public boolean supportsOpenStatementsAcrossRollback() throws SQLException - { - return true; - } - - /** - * How many hex characters can you have in an inline binary literal - * - * @return the max literal length - * @exception SQLException if a database access error occurs - */ - public int getMaxBinaryLiteralLength() throws SQLException - { - return 0; // For now... - } - - /** - * What is the maximum length for a character literal - * I suppose it is 8190 (8192 - 2 for the quotes) - * - * @return the max literal length - * @exception SQLException if a database access error occurs - */ - public int getMaxCharLiteralLength() throws SQLException - { - return 8190; - } - - /** - * Whats the limit on column name length. The description of - * pg_class would say '32' (length of pg_class.relname) - we - * should probably do a query for this....but.... - * - * @return the maximum column name length - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnNameLength() throws SQLException - { - return 32; - } - - /** - * What is the maximum number of columns in a "GROUP BY" clause? - * - * @return the max number of columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInGroupBy() throws SQLException - { - return getMaxColumnsInTable(); - } - - /** - * What's the maximum number of columns allowed in an index? - * 6.0 only allowed one column, but 6.1 introduced multi-column - * indices, so, theoretically, its all of them. - * - * @return max number of columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInIndex() throws SQLException - { - return getMaxColumnsInTable(); - } - - /** - * What's the maximum number of columns in an "ORDER BY clause? - * Theoretically, all of them! - * - * @return the max columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInOrderBy() throws SQLException - { - return getMaxColumnsInTable(); - } - - /** - * What is the maximum number of columns in a "SELECT" list? - * Theoretically, all of them! - * - * @return the max columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInSelect() throws SQLException - { - return getMaxColumnsInTable(); - } - - /** - * What is the maximum number of columns in a table? From the - * create_table(l) manual page... - * - *

"The new class is created as a heap with no initial data. A - * class can have no more than 1600 attributes (realistically, - * this is limited by the fact that tuple sizes must be less than - * 8192 bytes)..." - * - * @return the max columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInTable() throws SQLException - { - return 1600; - } - - /** - * How many active connection can we have at a time to this - * database? Well, since it depends on postmaster, which just - * does a listen() followed by an accept() and fork(), its - * basically very high. Unless the system runs out of processes, - * it can be 65535 (the number of aux. ports on a TCP/IP system). - * I will return 8192 since that is what even the largest system - * can realistically handle, - * - * @return the maximum number of connections - * @exception SQLException if a database access error occurs - */ - public int getMaxConnections() throws SQLException - { - return 8192; - } - - /** - * What is the maximum cursor name length (the same as all - * the other F***** identifiers!) - * - * @return max cursor name length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxCursorNameLength() throws SQLException - { - return 32; - } - - /** - * What is the maximum length of an index (in bytes)? Now, does - * the spec. mean name of an index (in which case its 32, the - * same as a table) or does it mean length of an index element - * (in which case its 8192, the size of a row) or does it mean - * the number of rows it can access (in which case it 2^32 - - * a 4 byte OID number)? I think its the length of an index - * element, personally, so Im setting it to 8192. - * - * @return max index length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxIndexLength() throws SQLException - { - return 8192; - } - - public int getMaxSchemaNameLength() throws SQLException - { - // XXX-Not Implemented - return 0; - } - - /** - * What is the maximum length of a procedure name? - * (length of pg_proc.proname used) - again, I really - * should do a query here to get it. - * - * @return the max name length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxProcedureNameLength() throws SQLException - { - return 32; - } - - public int getMaxCatalogNameLength() throws SQLException - { - // XXX-Not Implemented - return 0; - } - - /** - * What is the maximum length of a single row? (not including - * blobs). 8192 is defined in PostgreSQL. - * - * @return max row size in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxRowSize() throws SQLException - { - return 8192; - } - - /** - * Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY - * blobs? We don't handle blobs yet - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean doesMaxRowSizeIncludeBlobs() throws SQLException - { - return false; - } - - /** - * What is the maximum length of a SQL statement? - * - * @return max length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxStatementLength() throws SQLException - { - return 8192; - } - - /** - * How many active statements can we have open at one time to - * this database? Basically, since each Statement downloads - * the results as the query is executed, we can have many. However, - * we can only really have one statement per connection going - * at once (since they are executed serially) - so we return - * one. - * - * @return the maximum - * @exception SQLException if a database access error occurs - */ - public int getMaxStatements() throws SQLException - { - return 1; - } - - /** - * What is the maximum length of a table name? This was found - * from pg_class.relname length - * - * @return max name length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxTableNameLength() throws SQLException - { - return 32; - } - - /** - * What is the maximum number of tables that can be specified - * in a SELECT? Theoretically, this is the same number as the - * number of tables allowable. In practice tho, it is much smaller - * since the number of tables is limited by the statement, we - * return 1024 here - this is just a number I came up with (being - * the number of tables roughly of three characters each that you - * can fit inside a 8192 character buffer with comma separators). - * - * @return the maximum - * @exception SQLException if a database access error occurs - */ - public int getMaxTablesInSelect() throws SQLException - { - return 1024; - } - - /** - * What is the maximum length of a user name? Well, we generally - * use UNIX like user names in PostgreSQL, so I think this would - * be 8. However, showing the schema for pg_user shows a length - * for username of 32. - * - * @return the max name length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxUserNameLength() throws SQLException - { - return 32; - } - - - /** - * What is the database's default transaction isolation level? We - * do not support this, so all transactions are SERIALIZABLE. - * - * @return the default isolation level - * @exception SQLException if a database access error occurs - * @see Connection - */ - public int getDefaultTransactionIsolation() throws SQLException - { - return Connection.TRANSACTION_READ_COMMITTED; - } - - /** - * Are transactions supported? If not, commit and rollback are noops - * and the isolation level is TRANSACTION_NONE. We do support - * transactions. - * - * @return true if transactions are supported - * @exception SQLException if a database access error occurs - */ - public boolean supportsTransactions() throws SQLException - { - return true; - } - - /** - * Does the database support the given transaction isolation level? - * We only support TRANSACTION_SERIALIZABLE and TRANSACTION_READ_COMMITTED - * - * @param level the values are defined in java.sql.Connection - * @return true if so - * @exception SQLException if a database access error occurs - * @see Connection - */ - public boolean supportsTransactionIsolationLevel(int level) throws SQLException - { - if (level == Connection.TRANSACTION_SERIALIZABLE || - level == Connection.TRANSACTION_READ_COMMITTED) - return true; - else - return false; - } - - /** - * Are both data definition and data manipulation transactions - * supported? I checked it, and could not do a CREATE TABLE - * within a transaction, so I am assuming that we don't - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException - { - return false; - } - - /** - * Are only data manipulation statements withing a transaction - * supported? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsDataManipulationTransactionsOnly() throws SQLException - { - return true; - } - - /** - * Does a data definition statement within a transaction force - * the transaction to commit? I think this means something like: - * - * 

-   * CREATE TABLE T (A INT);
-   * INSERT INTO T (A) VALUES (2);
-   * BEGIN;
-   * UPDATE T SET A = A + 1;
-   * CREATE TABLE X (A INT);
-   * SELECT A FROM T INTO X;
-   * COMMIT;
-   *

- * - * does the CREATE TABLE call cause a commit? The answer is no. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean dataDefinitionCausesTransactionCommit() throws SQLException - { - return false; - } - - /** - * Is a data definition statement within a transaction ignored? - * It seems to be (from experiment in previous method) - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean dataDefinitionIgnoredInTransactions() throws SQLException - { - return true; - } - - /** - * Get a description of stored procedures available in a catalog - * - *

Only procedure descriptions matching the schema and procedure - * name criteria are returned. They are ordered by PROCEDURE_SCHEM - * and PROCEDURE_NAME - * - *

Each procedure description has the following columns: - *

    - *
  1. PROCEDURE_CAT String => procedure catalog (may be null) - *
  2. PROCEDURE_SCHEM String => procedure schema (may be null) - *
  3. PROCEDURE_NAME String => procedure name - *
  4. Field 4 reserved (make it null) - *
  5. Field 5 reserved (make it null) - *
  6. Field 6 reserved (make it null) - *
  7. REMARKS String => explanatory comment on the procedure - *
  8. PROCEDURE_TYPE short => kind of procedure - *
      - *
    • procedureResultUnknown - May return a result - *
    • procedureNoResult - Does not return a result - *
    • procedureReturnsResult - Returns a result - *
    - *
- * - * @param catalog - a catalog name; "" retrieves those without a - * catalog; null means drop catalog name from criteria - * @param schemaParrern - a schema name pattern; "" retrieves those - * without a schema - we ignore this parameter - * @param procedureNamePattern - a procedure name pattern - * @return ResultSet - each row is a procedure description - * @exception SQLException if a database access error occurs - */ - public java.sql.ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException - { - // the field descriptors for the new ResultSet - Field f[] = new Field[8]; - java.sql.ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - byte remarks[] = defaultRemarks; - - f[0] = new Field(connection, "PROCEDURE_CAT", iVarcharOid, 32); - f[1] = new Field(connection, "PROCEDURE_SCHEM", iVarcharOid, 32); - f[2] = new Field(connection, "PROCEDURE_NAME", iVarcharOid, 32); - f[3] = f[4] = f[5] = null; // reserved, must be null for now - f[6] = new Field(connection, "REMARKS", iVarcharOid, 8192); - f[7] = new Field(connection, "PROCEDURE_TYPE", iInt2Oid, 2); - - // If the pattern is null, then set it to the default - if(procedureNamePattern==null) - procedureNamePattern="%"; - - r = connection.ExecSQL("select proname, proretset from pg_proc where proname like '"+procedureNamePattern.toLowerCase()+"' order by proname"); - - while (r.next()) - { - byte[][] tuple = new byte[8][0]; - - tuple[0] = null; // Catalog name - tuple[1] = null; // Schema name - tuple[2] = r.getBytes(1); // Procedure name - tuple[3] = tuple[4] = tuple[5] = null; // Reserved - tuple[6] = remarks; // Remarks - - if (r.getBoolean(2)) - tuple[7] = Integer.toString(java.sql.DatabaseMetaData.procedureReturnsResult).getBytes(); - else - tuple[7] = Integer.toString(java.sql.DatabaseMetaData.procedureNoResult).getBytes(); - - v.addElement(tuple); - } - return new ResultSet(connection, f, v, "OK", 1); - } - - /** - * Get a description of a catalog's stored procedure parameters - * and result columns. - * - *

Only descriptions matching the schema, procedure and parameter - * name criteria are returned. They are ordered by PROCEDURE_SCHEM - * and PROCEDURE_NAME. Within this, the return value, if any, is - * first. Next are the parameter descriptions in call order. The - * column descriptions follow in column number order. - * - *

Each row in the ResultSet is a parameter description or column - * description with the following fields: - *

    - *
  1. PROCEDURE_CAT String => procedure catalog (may be null) - *
  2. PROCEDURE_SCHEM String => procedure schema (may be null) - *
  3. PROCEDURE_NAME String => procedure name - *
  4. COLUMN_NAME String => column/parameter name - *
  5. COLUMN_TYPE Short => kind of column/parameter: - *
    • procedureColumnUnknown - nobody knows - *
    • procedureColumnIn - IN parameter - *
    • procedureColumnInOut - INOUT parameter - *
    • procedureColumnOut - OUT parameter - *
    • procedureColumnReturn - procedure return value - *
    • procedureColumnResult - result column in ResultSet - *
    - *
  6. DATA_TYPE short => SQL type from java.sql.Types - *
  7. TYPE_NAME String => SQL type name - *
  8. PRECISION int => precision - *
  9. LENGTH int => length in bytes of data - *
  10. SCALE short => scale - *
  11. RADIX short => radix - *
  12. NULLABLE short => can it contain NULL? - *
    • procedureNoNulls - does not allow NULL values - *
    • procedureNullable - allows NULL values - *
    • procedureNullableUnknown - nullability unknown - *
    • REMARKS String => comment describing parameter/column - *
- * @param catalog This is ignored in postgresql, advise this is set to null - * @param schemaPattern This is ignored in postgresql, advise this is set to null - * @param procedureNamePattern a procedure name pattern - * @param columnNamePattern a column name pattern - * @return each row is a stored procedure parameter or column description - * @exception SQLException if a database-access error occurs - * @see #getSearchStringEscape - */ - // Implementation note: This is required for Borland's JBuilder to work - public java.sql.ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException - { - if(procedureNamePattern==null) - procedureNamePattern="%"; - - if(columnNamePattern==null) - columnNamePattern="%"; - - // for now, this returns an empty result set. - Field f[] = new Field[13]; - ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("PROCEDURE_CAT"), iVarcharOid, 32); - f[1] = new Field(connection, new String("PROCEDURE_SCHEM"), iVarcharOid, 32); - f[2] = new Field(connection, new String("PROCEDURE_NAME"), iVarcharOid, 32); - f[3] = new Field(connection, new String("COLUMN_NAME"), iVarcharOid, 32); - f[4] = new Field(connection, new String("COLUMN_TYPE"), iInt2Oid, 2); - f[5] = new Field(connection, new String("DATA_TYPE"), iInt2Oid, 2); - f[6] = new Field(connection, new String("TYPE_NAME"), iVarcharOid, 32); - f[7] = new Field(connection, new String("PRECISION"), iInt4Oid, 4); - f[8] = new Field(connection, new String("LENGTH"), iInt4Oid, 4); - f[9] = new Field(connection, new String("SCALE"), iInt2Oid, 2); - f[10] = new Field(connection, new String("RADIX"), iInt2Oid, 2); - f[11] = new Field(connection, new String("NULLABLE"), iInt2Oid, 2); - f[12] = new Field(connection, new String("REMARKS"), iVarcharOid, 32); - - // add query loop here - - return new ResultSet(connection, f, v, "OK", 1); - } - - /** - * Get a description of tables available in a catalog. - * - *

Only table descriptions matching the catalog, schema, table - * name and type criteria are returned. They are ordered by - * TABLE_TYPE, TABLE_SCHEM and TABLE_NAME. - * - *

Each table description has the following columns: - * - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. TABLE_TYPE String => table type. Typical types are "TABLE", - * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL - * TEMPORARY", "ALIAS", "SYNONYM". - *
  5. REMARKS String => explanatory comment on the table - *
- * - *

The valid values for the types parameter are: - * "TABLE", "INDEX", "SEQUENCE", "SYSTEM TABLE" and "SYSTEM INDEX" - * - * @param catalog a catalog name; For postgresql, this is ignored, and - * should be set to null - * @param schemaPattern a schema name pattern; For postgresql, this is ignored, and - * should be set to null - * @param tableNamePattern a table name pattern. For all tables this should be "%" - * @param types a list of table types to include; null returns - * all types - * @return each row is a table description - * @exception SQLException if a database-access error occurs. - */ - public java.sql.ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String types[]) throws SQLException - { - // Handle default value for types - if(types==null) - types = defaultTableTypes; - - if(tableNamePattern==null) - tableNamePattern="%"; - - // the field descriptors for the new ResultSet - Field f[] = new Field[5]; - java.sql.ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("TABLE_CAT"), iVarcharOid, 32); - f[1] = new Field(connection, new String("TABLE_SCHEM"), iVarcharOid, 32); - f[2] = new Field(connection, new String("TABLE_NAME"), iVarcharOid, 32); - f[3] = new Field(connection, new String("TABLE_TYPE"), iVarcharOid, 32); - f[4] = new Field(connection, new String("REMARKS"), iVarcharOid, 32); - - // Now form the query - StringBuffer sql = new StringBuffer("select relname,oid from pg_class where ("); - boolean notFirst=false; - for(int i=0;i - // Now take the pattern into account - sql.append(") and relname like '"); - sql.append(tableNamePattern.toLowerCase()); - sql.append("'"); - - // Now run the query - r = connection.ExecSQL(sql.toString()); - - byte remarks[]; - - while (r.next()) - { - byte[][] tuple = new byte[5][0]; - - // Fetch the description for the table (if any) - java.sql.ResultSet dr = connection.ExecSQL("select description from pg_description where objoid="+r.getInt(2)); - if(((postgresql.ResultSet)dr).getTupleCount()==1) { - dr.next(); - remarks = dr.getBytes(1); - } else - remarks = defaultRemarks; - dr.close(); - - tuple[0] = null; // Catalog name - tuple[1] = null; // Schema name - tuple[2] = r.getBytes(1); // Table name - tuple[3] = null; // Table type - tuple[4] = remarks; // Remarks - v.addElement(tuple); - } - r.close(); - return new ResultSet(connection, f, v, "OK", 1); - } - - // This array contains the valid values for the types argument - // in getTables(). - // - // Each supported type consists of it's name, and the sql where - // clause to retrieve that value. - // - // IMPORTANT: the query must be enclosed in ( ) - private static final String getTableTypes[][] = { - {"TABLE", "(relkind='r' and relname !~ '^pg_')"}, - {"INDEX", "(relkind='i' and relname !~ '^pg_')"}, - {"SEQUENCE", "(relkind='S' and relname !~ '^pg_')"}, - {"SYSTEM TABLE", "(relkind='r' and relname ~ '^pg_')"}, - {"SYSTEM INDEX", "(relkind='i' and relname ~ '^pg_')"} - }; - - // These are the default tables, used when NULL is passed to getTables - // The choice of these provide the same behaviour as psql's \d - private static final String defaultTableTypes[] = { - "TABLE","INDEX","SEQUENCE" - }; - - /** - * Get the schema names available in this database. The results - * are ordered by schema name. - * - *

The schema column is: - *

    - *
  1. TABLE_SCHEM String => schema name - *
- * - * @return ResultSet each row has a single String column that is a - * schema name - */ - public java.sql.ResultSet getSchemas() throws SQLException - { - // We don't use schemas, so we simply return a single schema name "". - // - Field f[] = new Field[1]; - Vector v = new Vector(); - byte[][] tuple = new byte[1][0]; - f[0] = new Field(connection,new String("TABLE_SCHEM"),iVarcharOid,32); - tuple[0] = "".getBytes(); - v.addElement(tuple); - return new ResultSet(connection,f,v,"OK",1); - } - - /** - * Get the catalog names available in this database. The results - * are ordered by catalog name. - * - *

The catalog column is: - *

    - *
  1. TABLE_CAT String => catalog name - *
- * - * @return ResultSet each row has a single String column that is a - * catalog name - */ - public java.sql.ResultSet getCatalogs() throws SQLException - { - // We don't use catalogs, so we simply return a single catalog name "". - Field f[] = new Field[1]; - Vector v = new Vector(); - byte[][] tuple = new byte[1][0]; - f[0] = new Field(connection,new String("TABLE_CAT"),iVarcharOid,32); - tuple[0] = "".getBytes(); - v.addElement(tuple); - return new ResultSet(connection,f,v,"OK",1); - } - - /** - * Get the table types available in this database. The results - * are ordered by table type. - * - *

The table type is: - *

    - *
  1. TABLE_TYPE String => table type. Typical types are "TABLE", - * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", - * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". - *
- * - * @return ResultSet each row has a single String column that is a - * table type - */ - public java.sql.ResultSet getTableTypes() throws SQLException - { - Field f[] = new Field[1]; - Vector v = new Vector(); - byte[][] tuple = new byte[1][0]; - f[0] = new Field(connection,new String("TABLE_TYPE"),iVarcharOid,32); - for(int i=0;iOnly column descriptions matching the catalog, schema, table - * and column name criteria are returned. They are ordered by - * TABLE_SCHEM, TABLE_NAME and ORDINAL_POSITION. - * - *

Each column description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. COLUMN_NAME String => column name - *
  5. DATA_TYPE short => SQL type from java.sql.Types - *
  6. TYPE_NAME String => Data source dependent type name - *
  7. COLUMN_SIZE int => column size. For char or date - * types this is the maximum number of characters, for numeric or - * decimal types this is precision. - *
  8. BUFFER_LENGTH is not used. - *
  9. DECIMAL_DIGITS int => the number of fractional digits - *
  10. NUM_PREC_RADIX int => Radix (typically either 10 or 2) - *
  11. NULLABLE int => is NULL allowed? - *
      - *
    • columnNoNulls - might not allow NULL values - *
    • columnNullable - definitely allows NULL values - *
    • columnNullableUnknown - nullability unknown - *
    - *
  12. REMARKS String => comment describing column (may be null) - *
  13. COLUMN_DEF String => default value (may be null) - *
  14. SQL_DATA_TYPE int => unused - *
  15. SQL_DATETIME_SUB int => unused - *
  16. CHAR_OCTET_LENGTH int => for char types the - * maximum number of bytes in the column - *
  17. ORDINAL_POSITION int => index of column in table - * (starting at 1) - *
  18. IS_NULLABLE String => "NO" means column definitely - * does not allow NULL values; "YES" means the column might - * allow NULL values. An empty string means nobody knows. - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schemaPattern a schema name pattern; "" retrieves those - * without a schema - * @param tableNamePattern a table name pattern - * @param columnNamePattern a column name pattern - * @return ResultSet each row is a column description - * @see #getSearchStringEscape - */ - public java.sql.ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException - { - // the field descriptors for the new ResultSet - Field f[] = new Field[18]; - java.sql.ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("TABLE_CAT"), iVarcharOid, 32); - f[1] = new Field(connection, new String("TABLE_SCHEM"), iVarcharOid, 32); - f[2] = new Field(connection, new String("TABLE_NAME"), iVarcharOid, 32); - f[3] = new Field(connection, new String("COLUMN_NAME"), iVarcharOid, 32); - f[4] = new Field(connection, new String("DATA_TYPE"), iInt2Oid, 2); - f[5] = new Field(connection, new String("TYPE_NAME"), iVarcharOid, 32); - f[6] = new Field(connection, new String("COLUMN_SIZE"), iInt4Oid, 4); - f[7] = new Field(connection, new String("BUFFER_LENGTH"), iVarcharOid, 32); - f[8] = new Field(connection, new String("DECIMAL_DIGITS"), iInt4Oid, 4); - f[9] = new Field(connection, new String("NUM_PREC_RADIX"), iInt4Oid, 4); - f[10] = new Field(connection, new String("NULLABLE"), iInt4Oid, 4); - f[11] = new Field(connection, new String("REMARKS"), iVarcharOid, 32); - f[12] = new Field(connection, new String("COLUMN_DEF"), iVarcharOid, 32); - f[13] = new Field(connection, new String("SQL_DATA_TYPE"), iInt4Oid, 4); - f[14] = new Field(connection, new String("SQL_DATETIME_SUB"), iInt4Oid, 4); - f[15] = new Field(connection, new String("CHAR_OCTET_LENGTH"), iVarcharOid, 32); - f[16] = new Field(connection, new String("ORDINAL_POSITION"), iInt4Oid,4); - f[17] = new Field(connection, new String("IS_NULLABLE"), iVarcharOid, 32); - - // Added by Stefan Andreasen - // If the pattern are null then set them to % - if (tableNamePattern == null) tableNamePattern="%"; - if (columnNamePattern == null) columnNamePattern="%"; - - // Now form the query - // Modified by Stefan Andreasen - r = connection.ExecSQL("select a.oid,c.relname,a.attname,a.atttypid,a.attnum,a.attnotnull,a.attlen,a.atttypmod from pg_class c, pg_attribute a where a.attrelid=c.oid and c.relname like '"+tableNamePattern.toLowerCase()+"' and a.attname like '"+columnNamePattern.toLowerCase()+"' and a.attnum>0 order by c.relname,a.attnum"); - - byte remarks[]; - - while(r.next()) { - byte[][] tuple = new byte[18][0]; - - // Fetch the description for the table (if any) - java.sql.ResultSet dr = connection.ExecSQL("select description from pg_description where objoid="+r.getInt(1)); - if(((postgresql.ResultSet)dr).getTupleCount()==1) { - dr.next(); - tuple[11] = dr.getBytes(1); - } else - tuple[11] = defaultRemarks; - - dr.close(); - - tuple[0] = "".getBytes(); // Catalog name - tuple[1] = "".getBytes(); // Schema name - tuple[2] = r.getBytes(2); // Table name - tuple[3] = r.getBytes(3); // Column name - - dr = connection.ExecSQL("select typname from pg_type where oid = "+r.getString(4)); - dr.next(); - String typname=dr.getString(1); - dr.close(); - tuple[4] = Integer.toString(Field.getSQLType(typname)).getBytes(); // Data type - tuple[5] = typname.getBytes(); // Type name - - // Column size - // Looking at the psql source, - // I think the length of a varchar as specified when the table was created - // should be extracted from atttypmod which contains this length + sizeof(int32) - if (typname.equals("bpchar") || typname.equals("varchar")) { - int atttypmod = r.getInt(8); - tuple[6] = Integer.toString(atttypmod != -1 ? atttypmod - VARHDRSZ : 0).getBytes(); - } else - tuple[6] = r.getBytes(7); - - tuple[7] = null; // Buffer length - - tuple[8] = "0".getBytes(); // Decimal Digits - how to get this? - tuple[9] = "10".getBytes(); // Num Prec Radix - assume decimal - - // tuple[10] is below - // tuple[11] is above - - tuple[12] = null; // column default - - tuple[13] = null; // sql data type (unused) - tuple[14] = null; // sql datetime sub (unused) - - tuple[15] = tuple[6]; // char octet length - - tuple[16] = r.getBytes(5); // ordinal position - - String nullFlag = r.getString(6); - tuple[10] = Integer.toString(nullFlag.equals("f")?java.sql.DatabaseMetaData.columnNullable:java.sql.DatabaseMetaData.columnNoNulls).getBytes(); // Nullable - tuple[17] = (nullFlag.equals("f")?"YES":"NO").getBytes(); // is nullable - - v.addElement(tuple); - } - r.close(); - return new ResultSet(connection, f, v, "OK", 1); - } - - /** - * Get a description of the access rights for a table's columns. - * - *

Only privileges matching the column name criteria are - * returned. They are ordered by COLUMN_NAME and PRIVILEGE. - * - *

Each privilige description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. COLUMN_NAME String => column name - *
  5. GRANTOR => grantor of access (may be null) - *
  6. GRANTEE String => grantee of access - *
  7. PRIVILEGE String => name of access (SELECT, - * INSERT, UPDATE, REFRENCES, ...) - *
  8. IS_GRANTABLE String => "YES" if grantee is permitted - * to grant to others; "NO" if not; null if unknown - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name; "" retrieves those without a schema - * @param table a table name - * @param columnNamePattern a column name pattern - * @return ResultSet each row is a column privilege description - * @see #getSearchStringEscape - */ - public java.sql.ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern) throws SQLException - { - Field f[] = new Field[8]; - Vector v = new Vector(); - - if(table==null) - table="%"; - - if(columnNamePattern==null) - columnNamePattern="%"; - else - columnNamePattern=columnNamePattern.toLowerCase(); - - f[0] = new Field(connection,new String("TABLE_CAT"),iVarcharOid,32); - f[1] = new Field(connection,new String("TABLE_SCHEM"),iVarcharOid,32); - f[2] = new Field(connection,new String("TABLE_NAME"),iVarcharOid,32); - f[3] = new Field(connection,new String("COLUMN_NAME"),iVarcharOid,32); - f[4] = new Field(connection,new String("GRANTOR"),iVarcharOid,32); - f[5] = new Field(connection,new String("GRANTEE"),iVarcharOid,32); - f[6] = new Field(connection,new String("PRIVILEGE"),iVarcharOid,32); - f[7] = new Field(connection,new String("IS_GRANTABLE"),iVarcharOid,32); - - // This is taken direct from the psql source - java.sql.ResultSet r = connection.ExecSQL("SELECT relname, relacl FROM pg_class, pg_user WHERE ( relkind = 'r' OR relkind = 'i') and relname !~ '^pg_' and relname !~ '^xin[vx][0-9]+' and usesysid = relowner and relname like '"+table.toLowerCase()+"' ORDER BY relname"); - while(r.next()) { - byte[][] tuple = new byte[8][0]; - tuple[0] = tuple[1]= "".getBytes(); - DriverManager.println("relname=\""+r.getString(1)+"\" relacl=\""+r.getString(2)+"\""); - - // For now, don't add to the result as relacl needs to be processed. - //v.addElement(tuple); - } - - return new ResultSet(connection,f,v,"OK",1); - } - - /** - * Get a description of the access rights for each table available - * in a catalog. - * - *

Only privileges matching the schema and table name - * criteria are returned. They are ordered by TABLE_SCHEM, - * TABLE_NAME, and PRIVILEGE. - * - *

Each privilige description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. COLUMN_NAME String => column name - *
  5. GRANTOR => grantor of access (may be null) - *
  6. GRANTEE String => grantee of access - *
  7. PRIVILEGE String => name of access (SELECT, - * INSERT, UPDATE, REFRENCES, ...) - *
  8. IS_GRANTABLE String => "YES" if grantee is permitted - * to grant to others; "NO" if not; null if unknown - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schemaPattern a schema name pattern; "" retrieves those - * without a schema - * @param tableNamePattern a table name pattern - * @return ResultSet each row is a table privilege description - * @see #getSearchStringEscape - */ - public java.sql.ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of a table's optimal set of columns that - * uniquely identifies a row. They are ordered by SCOPE. - * - *

Each column description has the following columns: - *

    - *
  1. SCOPE short => actual scope of result - *
      - *
    • bestRowTemporary - very temporary, while using row - *
    • bestRowTransaction - valid for remainder of current transaction - *
    • bestRowSession - valid for remainder of current session - *
    - *
  2. COLUMN_NAME String => column name - *
  3. DATA_TYPE short => SQL data type from java.sql.Types - *
  4. TYPE_NAME String => Data source dependent type name - *
  5. COLUMN_SIZE int => precision - *
  6. BUFFER_LENGTH int => not used - *
  7. DECIMAL_DIGITS short => scale - *
  8. PSEUDO_COLUMN short => is this a pseudo column - * like an Oracle ROWID - *
      - *
    • bestRowUnknown - may or may not be pseudo column - *
    • bestRowNotPseudo - is NOT a pseudo column - *
    • bestRowPseudo - is a pseudo column - *
    - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name; "" retrieves those without a schema - * @param table a table name - * @param scope the scope of interest; use same values as SCOPE - * @param nullable include columns that are nullable? - * @return ResultSet each row is a column description - */ - // Implementation note: This is required for Borland's JBuilder to work - public java.sql.ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable) throws SQLException - { - // for now, this returns an empty result set. - Field f[] = new Field[8]; - ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("SCOPE"), iInt2Oid, 2); - f[1] = new Field(connection, new String("COLUMN_NAME"), iVarcharOid, 32); - f[2] = new Field(connection, new String("DATA_TYPE"), iInt2Oid, 2); - f[3] = new Field(connection, new String("TYPE_NAME"), iVarcharOid, 32); - f[4] = new Field(connection, new String("COLUMN_SIZE"), iInt4Oid, 4); - f[5] = new Field(connection, new String("BUFFER_LENGTH"), iInt4Oid, 4); - f[6] = new Field(connection, new String("DECIMAL_DIGITS"), iInt2Oid, 2); - f[7] = new Field(connection, new String("PSEUDO_COLUMN"), iInt2Oid, 2); - - return new ResultSet(connection, f, v, "OK", 1); - } - - /** - * Get a description of a table's columns that are automatically - * updated when any value in a row is updated. They are - * unordered. - * - *

Each column description has the following columns: - *

    - *
  1. SCOPE short => is not used - *
  2. COLUMN_NAME String => column name - *
  3. DATA_TYPE short => SQL data type from java.sql.Types - *
  4. TYPE_NAME String => Data source dependent type name - *
  5. COLUMN_SIZE int => precision - *
  6. BUFFER_LENGTH int => length of column value in bytes - *
  7. DECIMAL_DIGITS short => scale - *
  8. PSEUDO_COLUMN short => is this a pseudo column - * like an Oracle ROWID - *
      - *
    • versionColumnUnknown - may or may not be pseudo column - *
    • versionColumnNotPseudo - is NOT a pseudo column - *
    • versionColumnPseudo - is a pseudo column - *
    - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name; "" retrieves those without a schema - * @param table a table name - * @return ResultSet each row is a column description - */ - public java.sql.ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of a table's primary key columns. They - * are ordered by COLUMN_NAME. - * - *

Each column description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. COLUMN_NAME String => column name - *
  5. KEY_SEQ short => sequence number within primary key - *
  6. PK_NAME String => primary key name (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those - * without a schema - * @param table a table name - * @return ResultSet each row is a primary key column description - */ - public java.sql.ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException - { - return connection.createStatement().executeQuery("SELECT " + - "'' as TABLE_CAT," + - "'' AS TABLE_SCHEM," + - "bc.relname AS TABLE_NAME," + - "a.attname AS COLUMN_NAME," + - "a.attnum as KEY_SEQ,"+ - "ic.relname as PK_NAME " + - " FROM pg_class bc, pg_class ic, pg_index i, pg_attribute a" + - " WHERE bc.relkind = 'r' " + // -- not indices - " and upper(bc.relname) = upper('"+table+"')" + - " and i.indrelid = bc.oid" + - " and i.indexrelid = ic.oid" + - " and ic.oid = a.attrelid" + - " and i.indisprimary='t' " + - " ORDER BY table_name, pk_name, key_seq" - ); - } - - /** - * Get a description of the primary key columns that are - * referenced by a table's foreign key columns (the primary keys - * imported by a table). They are ordered by PKTABLE_CAT, - * PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ. - * - *

Each primary key column description has the following columns: - *

    - *
  1. PKTABLE_CAT String => primary key table catalog - * being imported (may be null) - *
  2. PKTABLE_SCHEM String => primary key table schema - * being imported (may be null) - *
  3. PKTABLE_NAME String => primary key table name - * being imported - *
  4. PKCOLUMN_NAME String => primary key column name - * being imported - *
  5. FKTABLE_CAT String => foreign key table catalog (may be null) - *
  6. FKTABLE_SCHEM String => foreign key table schema (may be null) - *
  7. FKTABLE_NAME String => foreign key table name - *
  8. FKCOLUMN_NAME String => foreign key column name - *
  9. KEY_SEQ short => sequence number within foreign key - *
  10. UPDATE_RULE short => What happens to - * foreign key when primary is updated: - *
      - *
    • importedKeyCascade - change imported key to agree - * with primary key update - *
    • importedKeyRestrict - do not allow update of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been updated - *
    - *
  11. DELETE_RULE short => What happens to - * the foreign key when primary is deleted. - *
      - *
    • importedKeyCascade - delete rows that import a deleted key - *
    • importedKeyRestrict - do not allow delete of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been deleted - *
    - *
  12. FK_NAME String => foreign key name (may be null) - *
  13. PK_NAME String => primary key name (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those - * without a schema - * @param table a table name - * @return ResultSet each row is a primary key column description - * @see #getExportedKeys - */ - public java.sql.ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of a foreign key columns that reference a - * table's primary key columns (the foreign keys exported by a - * table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM, - * FKTABLE_NAME, and KEY_SEQ. - * - *

Each foreign key column description has the following columns: - *

    - *
  1. PKTABLE_CAT String => primary key table catalog (may be null) - *
  2. PKTABLE_SCHEM String => primary key table schema (may be null) - *
  3. PKTABLE_NAME String => primary key table name - *
  4. PKCOLUMN_NAME String => primary key column name - *
  5. FKTABLE_CAT String => foreign key table catalog (may be null) - * being exported (may be null) - *
  6. FKTABLE_SCHEM String => foreign key table schema (may be null) - * being exported (may be null) - *
  7. FKTABLE_NAME String => foreign key table name - * being exported - *
  8. FKCOLUMN_NAME String => foreign key column name - * being exported - *
  9. KEY_SEQ short => sequence number within foreign key - *
  10. UPDATE_RULE short => What happens to - * foreign key when primary is updated: - *
      - *
    • importedKeyCascade - change imported key to agree - * with primary key update - *
    • importedKeyRestrict - do not allow update of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been updated - *
    - *
  11. DELETE_RULE short => What happens to - * the foreign key when primary is deleted. - *
      - *
    • importedKeyCascade - delete rows that import a deleted key - *
    • importedKeyRestrict - do not allow delete of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been deleted - *
    - *
  12. FK_NAME String => foreign key identifier (may be null) - *
  13. PK_NAME String => primary key identifier (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those - * without a schema - * @param table a table name - * @return ResultSet each row is a foreign key column description - * @see #getImportedKeys - */ - public java.sql.ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of the foreign key columns in the foreign key - * table that reference the primary key columns of the primary key - * table (describe how one table imports another's key.) This - * should normally return a single foreign key/primary key pair - * (most tables only import a foreign key from a table once.) They - * are ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and - * KEY_SEQ. - * - *

Each foreign key column description has the following columns: - *

    - *
  1. PKTABLE_CAT String => primary key table catalog (may be null) - *
  2. PKTABLE_SCHEM String => primary key table schema (may be null) - *
  3. PKTABLE_NAME String => primary key table name - *
  4. PKCOLUMN_NAME String => primary key column name - *
  5. FKTABLE_CAT String => foreign key table catalog (may be null) - * being exported (may be null) - *
  6. FKTABLE_SCHEM String => foreign key table schema (may be null) - * being exported (may be null) - *
  7. FKTABLE_NAME String => foreign key table name - * being exported - *
  8. FKCOLUMN_NAME String => foreign key column name - * being exported - *
  9. KEY_SEQ short => sequence number within foreign key - *
  10. UPDATE_RULE short => What happens to - * foreign key when primary is updated: - *
      - *
    • importedKeyCascade - change imported key to agree - * with primary key update - *
    • importedKeyRestrict - do not allow update of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been updated - *
    - *
  11. DELETE_RULE short => What happens to - * the foreign key when primary is deleted. - *
      - *
    • importedKeyCascade - delete rows that import a deleted key - *
    • importedKeyRestrict - do not allow delete of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been deleted - *
    - *
  12. FK_NAME String => foreign key identifier (may be null) - *
  13. PK_NAME String => primary key identifier (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those - * without a schema - * @param table a table name - * @return ResultSet each row is a foreign key column description - * @see #getImportedKeys - */ - public java.sql.ResultSet getCrossReference(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of all the standard SQL types supported by - * this database. They are ordered by DATA_TYPE and then by how - * closely the data type maps to the corresponding JDBC SQL type. - * - *

Each type description has the following columns: - *

    - *
  1. TYPE_NAME String => Type name - *
  2. DATA_TYPE short => SQL data type from java.sql.Types - *
  3. PRECISION int => maximum precision - *
  4. LITERAL_PREFIX String => prefix used to quote a literal - * (may be null) - *
  5. LITERAL_SUFFIX String => suffix used to quote a literal - (may be null) - *
  6. CREATE_PARAMS String => parameters used in creating - * the type (may be null) - *
  7. NULLABLE short => can you use NULL for this type? - *
      - *
    • typeNoNulls - does not allow NULL values - *
    • typeNullable - allows NULL values - *
    • typeNullableUnknown - nullability unknown - *
    - *
  8. CASE_SENSITIVE boolean=> is it case sensitive? - *
  9. SEARCHABLE short => can you use "WHERE" based on this type: - *
      - *
    • typePredNone - No support - *
    • typePredChar - Only supported with WHERE .. LIKE - *
    • typePredBasic - Supported except for WHERE .. LIKE - *
    • typeSearchable - Supported for all WHERE .. - *
    - *
  10. UNSIGNED_ATTRIBUTE boolean => is it unsigned? - *
  11. FIXED_PREC_SCALE boolean => can it be a money value? - *
  12. AUTO_INCREMENT boolean => can it be used for an - * auto-increment value? - *
  13. LOCAL_TYPE_NAME String => localized version of type name - * (may be null) - *
  14. MINIMUM_SCALE short => minimum scale supported - *
  15. MAXIMUM_SCALE short => maximum scale supported - *
  16. SQL_DATA_TYPE int => unused - *
  17. SQL_DATETIME_SUB int => unused - *
  18. NUM_PREC_RADIX int => usually 2 or 10 - *
- * - * @return ResultSet each row is a SQL type description - */ - public java.sql.ResultSet getTypeInfo() throws SQLException - { - java.sql.ResultSet rs = connection.ExecSQL("select typname from pg_type"); - if(rs!=null) { - Field f[] = new Field[18]; - ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("TYPE_NAME"), iVarcharOid, 32); - f[1] = new Field(connection, new String("DATA_TYPE"), iInt2Oid, 2); - f[2] = new Field(connection, new String("PRECISION"), iInt4Oid, 4); - f[3] = new Field(connection, new String("LITERAL_PREFIX"), iVarcharOid, 32); - f[4] = new Field(connection, new String("LITERAL_SUFFIX"), iVarcharOid, 32); - f[5] = new Field(connection, new String("CREATE_PARAMS"), iVarcharOid, 32); - f[6] = new Field(connection, new String("NULLABLE"), iInt2Oid, 2); - f[7] = new Field(connection, new String("CASE_SENSITIVE"), iBoolOid, 1); - f[8] = new Field(connection, new String("SEARCHABLE"), iInt2Oid, 2); - f[9] = new Field(connection, new String("UNSIGNED_ATTRIBUTE"), iBoolOid, 1); - f[10] = new Field(connection, new String("FIXED_PREC_SCALE"), iBoolOid, 1); - f[11] = new Field(connection, new String("AUTO_INCREMENT"), iBoolOid, 1); - f[12] = new Field(connection, new String("LOCAL_TYPE_NAME"), iVarcharOid, 32); - f[13] = new Field(connection, new String("MINIMUM_SCALE"), iInt2Oid, 2); - f[14] = new Field(connection, new String("MAXIMUM_SCALE"), iInt2Oid, 2); - f[15] = new Field(connection, new String("SQL_DATA_TYPE"), iInt4Oid, 4); - f[16] = new Field(connection, new String("SQL_DATETIME_SUB"), iInt4Oid, 4); - f[17] = new Field(connection, new String("NUM_PREC_RADIX"), iInt4Oid, 4); - - // cache some results, this will keep memory useage down, and speed - // things up a little. - byte b9[] = "9".getBytes(); - byte b10[] = "10".getBytes(); - byte bf[] = "f".getBytes(); - byte bnn[] = Integer.toString(typeNoNulls).getBytes(); - byte bts[] = Integer.toString(typeSearchable).getBytes(); - - while(rs.next()) { - byte[][] tuple = new byte[18][]; - String typname=rs.getString(1); - tuple[0] = typname.getBytes(); - tuple[1] = Integer.toString(Field.getSQLType(typname)).getBytes(); - tuple[2] = b9; // for now - tuple[6] = bnn; // for now - tuple[7] = bf; // false for now - not case sensitive - tuple[8] = bts; - tuple[9] = bf; // false for now - it's signed - tuple[10] = bf; // false for now - must handle money - tuple[11] = bf; // false for now - handle autoincrement - // 12 - LOCAL_TYPE_NAME is null - // 13 & 14 ? - // 15 & 16 are unused so we return null - tuple[17] = b10; // everything is base 10 - v.addElement(tuple); - } - rs.close(); - return new ResultSet(connection, f, v, "OK", 1); - } - - return null; - } - - /** - * Get a description of a table's indices and statistics. They are - * ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION. - * - *

Each index column description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. NON_UNIQUE boolean => Can index values be non-unique? - * false when TYPE is tableIndexStatistic - *
  5. INDEX_QUALIFIER String => index catalog (may be null); - * null when TYPE is tableIndexStatistic - *
  6. INDEX_NAME String => index name; null when TYPE is - * tableIndexStatistic - *
  7. TYPE short => index type: - *
      - *
    • tableIndexStatistic - this identifies table statistics that are - * returned in conjuction with a table's index descriptions - *
    • tableIndexClustered - this is a clustered index - *
    • tableIndexHashed - this is a hashed index - *
    • tableIndexOther - this is some other style of index - *
    - *
  8. ORDINAL_POSITION short => column sequence number - * within index; zero when TYPE is tableIndexStatistic - *
  9. COLUMN_NAME String => column name; null when TYPE is - * tableIndexStatistic - *
  10. ASC_OR_DESC String => column sort sequence, "A" => ascending - * "D" => descending, may be null if sort sequence is not supported; - * null when TYPE is tableIndexStatistic - *
  11. CARDINALITY int => When TYPE is tableIndexStatisic then - * this is the number of rows in the table; otherwise it is the - * number of unique values in the index. - *
  12. PAGES int => When TYPE is tableIndexStatisic then - * this is the number of pages used for the table, otherwise it - * is the number of pages used for the current index. - *
  13. FILTER_CONDITION String => Filter condition, if any. - * (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those without a schema - * @param table a table name - * @param unique when true, return only indices for unique values; - * when false, return indices regardless of whether unique or not - * @param approximate when true, result is allowed to reflect approximate - * or out of data values; when false, results are requested to be - * accurate - * @return ResultSet each row is an index column description - */ - // Implementation note: This is required for Borland's JBuilder to work - public java.sql.ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate) throws SQLException - { - // for now, this returns an empty result set. - Field f[] = new Field[13]; - ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("TABLE_CAT"), iVarcharOid, 32); - f[1] = new Field(connection, new String("TABLE_SCHEM"), iVarcharOid, 32); - f[2] = new Field(connection, new String("TABLE_NAME"), iVarcharOid, 32); - f[3] = new Field(connection, new String("NON_UNIQUE"), iBoolOid, 1); - f[4] = new Field(connection, new String("INDEX_QUALIFIER"), iVarcharOid, 32); - f[5] = new Field(connection, new String("INDEX_NAME"), iVarcharOid, 32); - f[6] = new Field(connection, new String("TYPE"), iInt2Oid, 2); - f[7] = new Field(connection, new String("ORDINAL_POSITION"), iInt2Oid, 2); - f[8] = new Field(connection, new String("COLUMN_NAME"), iVarcharOid, 32); - f[9] = new Field(connection, new String("ASC_OR_DESC"), iVarcharOid, 32); - f[10] = new Field(connection, new String("CARDINALITY"), iInt4Oid, 4); - f[11] = new Field(connection, new String("PAGES"), iInt4Oid, 4); - f[12] = new Field(connection, new String("FILTER_CONDITION"), iVarcharOid, 32); - - return new ResultSet(connection, f, v, "OK", 1); - } -} - diff --git a/src/interfaces/jdbc/postgresql/jdbc1/PreparedStatement.java b/src/interfaces/jdbc/postgresql/jdbc1/PreparedStatement.java deleted file mode 100644 index 69bb426624..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc1/PreparedStatement.java +++ /dev/null @@ -1,600 +0,0 @@ -package postgresql.jdbc1; - -// IMPORTANT NOTE: This file implements the JDBC 1 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 2 class in the -// postgresql.jdbc2 package. - -import java.io.*; -import java.math.*; -import java.sql.*; -import java.text.*; -import java.util.*; -import postgresql.largeobject.*; -import postgresql.util.*; - -/** - * A SQL Statement is pre-compiled and stored in a PreparedStatement object. - * This object can then be used to efficiently execute this statement multiple - * times. - * - *

Note: The setXXX methods for setting IN parameter values must - * specify types that are compatible with the defined SQL type of the input - * parameter. For instance, if the IN parameter has SQL type Integer, then - * setInt should be used. - * - *

If arbitrary parameter type conversions are required, then the setObject - * method should be used with a target SQL type. - * - * @see ResultSet - * @see java.sql.PreparedStatement - */ -public class PreparedStatement extends Statement implements java.sql.PreparedStatement -{ - String sql; - String[] templateStrings; - String[] inStrings; - Connection connection; - - /** - * Constructor for the PreparedStatement class. - * Split the SQL statement into segments - separated by the arguments. - * When we rebuild the thing with the arguments, we can substitute the - * args and join the whole thing together. - * - * @param conn the instanatiating connection - * @param sql the SQL statement with ? for IN markers - * @exception SQLException if something bad occurs - */ - public PreparedStatement(Connection connection, String sql) throws SQLException - { - super(connection); - - Vector v = new Vector(); - boolean inQuotes = false; - int lastParmEnd = 0, i; - - this.sql = sql; - this.connection = connection; - for (i = 0; i < sql.length(); ++i) - { - int c = sql.charAt(i); - - if (c == '\'') - inQuotes = !inQuotes; - if (c == '?' && !inQuotes) - { - v.addElement(sql.substring (lastParmEnd, i)); - lastParmEnd = i + 1; - } - } - v.addElement(sql.substring (lastParmEnd, sql.length())); - - templateStrings = new String[v.size()]; - inStrings = new String[v.size() - 1]; - clearParameters(); - - for (i = 0 ; i < templateStrings.length; ++i) - templateStrings[i] = (String)v.elementAt(i); - } - - /** - * A Prepared SQL query is executed and its ResultSet is returned - * - * @return a ResultSet that contains the data produced by the - * query - never null - * @exception SQLException if a database access error occurs - */ - public java.sql.ResultSet executeQuery() throws SQLException - { - StringBuffer s = new StringBuffer(); - int i; - - for (i = 0 ; i < inStrings.length ; ++i) - { - if (inStrings[i] == null) - throw new PSQLException("postgresql.prep.param",new Integer(i + 1)); - s.append (templateStrings[i]); - s.append (inStrings[i]); - } - s.append(templateStrings[inStrings.length]); - return super.executeQuery(s.toString()); // in Statement class - } - - /** - * Execute a SQL INSERT, UPDATE or DELETE statement. In addition, - * SQL statements that return nothing such as SQL DDL statements can - * be executed. - * - * @return either the row count for INSERT, UPDATE or DELETE; or - * 0 for SQL statements that return nothing. - * @exception SQLException if a database access error occurs - */ - public int executeUpdate() throws SQLException - { - StringBuffer s = new StringBuffer(); - int i; - - for (i = 0 ; i < inStrings.length ; ++i) - { - if (inStrings[i] == null) - throw new PSQLException("postgresql.prep.param",new Integer(i + 1)); - s.append (templateStrings[i]); - s.append (inStrings[i]); - } - s.append(templateStrings[inStrings.length]); - return super.executeUpdate(s.toString()); // in Statement class - } - - /** - * Set a parameter to SQL NULL - * - *

Note: You must specify the parameters SQL type (although - * PostgreSQL ignores it) - * - * @param parameterIndex the first parameter is 1, etc... - * @param sqlType the SQL type code defined in java.sql.Types - * @exception SQLException if a database access error occurs - */ - public void setNull(int parameterIndex, int sqlType) throws SQLException - { - set(parameterIndex, "null"); - } - - /** - * Set a parameter to a Java boolean value. The driver converts this - * to a SQL BIT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setBoolean(int parameterIndex, boolean x) throws SQLException - { - set(parameterIndex, x ? "'t'" : "'f'"); - } - - /** - * Set a parameter to a Java byte value. The driver converts this to - * a SQL TINYINT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setByte(int parameterIndex, byte x) throws SQLException - { - set(parameterIndex, (new Integer(x)).toString()); - } - - /** - * Set a parameter to a Java short value. The driver converts this - * to a SQL SMALLINT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setShort(int parameterIndex, short x) throws SQLException - { - set(parameterIndex, (new Integer(x)).toString()); - } - - /** - * Set a parameter to a Java int value. The driver converts this to - * a SQL INTEGER value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setInt(int parameterIndex, int x) throws SQLException - { - set(parameterIndex, (new Integer(x)).toString()); - } - - /** - * Set a parameter to a Java long value. The driver converts this to - * a SQL BIGINT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setLong(int parameterIndex, long x) throws SQLException - { - set(parameterIndex, (new Long(x)).toString()); - } - - /** - * Set a parameter to a Java float value. The driver converts this - * to a SQL FLOAT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setFloat(int parameterIndex, float x) throws SQLException - { - set(parameterIndex, (new Float(x)).toString()); - } - - /** - * Set a parameter to a Java double value. The driver converts this - * to a SQL DOUBLE value when it sends it to the database - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setDouble(int parameterIndex, double x) throws SQLException - { - set(parameterIndex, (new Double(x)).toString()); - } - - /** - * Set a parameter to a java.lang.BigDecimal value. The driver - * converts this to a SQL NUMERIC value when it sends it to the - * database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException - { - set(parameterIndex, x.toString()); - } - - /** - * Set a parameter to a Java String value. The driver converts this - * to a SQL VARCHAR or LONGVARCHAR value (depending on the arguments - * size relative to the driver's limits on VARCHARs) when it sends it - * to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setString(int parameterIndex, String x) throws SQLException - { - // if the passed string is null, then set this column to null - if(x==null) - set(parameterIndex,"null"); - else { - StringBuffer b = new StringBuffer(); - int i; - - b.append('\''); - for (i = 0 ; i < x.length() ; ++i) - { - char c = x.charAt(i); - if (c == '\\' || c == '\'') - b.append((char)'\\'); - b.append(c); - } - b.append('\''); - set(parameterIndex, b.toString()); - } - } - - /** - * Set a parameter to a Java array of bytes. The driver converts this - * to a SQL VARBINARY or LONGVARBINARY (depending on the argument's - * size relative to the driver's limits on VARBINARYs) when it sends - * it to the database. - * - *

Implementation note: - *
With postgresql, this creates a large object, and stores the - * objects oid in this column. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setBytes(int parameterIndex, byte x[]) throws SQLException - { - LargeObjectManager lom = connection.getLargeObjectAPI(); - int oid = lom.create(); - LargeObject lob = lom.open(oid); - lob.write(x); - lob.close(); - setInt(parameterIndex,oid); - } - - /** - * Set a parameter to a java.sql.Date value. The driver converts this - * to a SQL DATE value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setDate(int parameterIndex, java.sql.Date x) throws SQLException - { - SimpleDateFormat df = new SimpleDateFormat("''yyyy-MM-dd''"); - - set(parameterIndex, df.format(x)); - - // The above is how the date should be handled. - // - // However, in JDK's prior to 1.1.6 (confirmed with the - // Linux jdk1.1.3 and the Win95 JRE1.1.5), SimpleDateFormat seems - // to format a date to the previous day. So the fix is to add a day - // before formatting. - // - // PS: 86400000 is one day - // - //set(parameterIndex, df.format(new java.util.Date(x.getTime()+86400000))); - } - - /** - * Set a parameter to a java.sql.Time value. The driver converts - * this to a SQL TIME value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1...)); - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setTime(int parameterIndex, Time x) throws SQLException - { - set(parameterIndex, "'" + x.toString() + "'"); - } - - /** - * Set a parameter to a java.sql.Timestamp value. The driver converts - * this to a SQL TIMESTAMP value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException - { - set(parameterIndex, "'" + x.toString() + "'"); - } - - /** - * When a very large ASCII value is input to a LONGVARCHAR parameter, - * it may be more practical to send it via a java.io.InputStream. - * JDBC will read the data from the stream as needed, until it reaches - * end-of-file. The JDBC driver will do any necessary conversion from - * ASCII to the database char format. - * - *

Note: This stream object can either be a standard Java - * stream object or your own subclass that implements the standard - * interface. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @param length the number of bytes in the stream - * @exception SQLException if a database access error occurs - */ - public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException - { - setBinaryStream(parameterIndex, x, length); - } - - /** - * When a very large Unicode value is input to a LONGVARCHAR parameter, - * it may be more practical to send it via a java.io.InputStream. - * JDBC will read the data from the stream as needed, until it reaches - * end-of-file. The JDBC driver will do any necessary conversion from - * UNICODE to the database char format. - * - *

Note: This stream object can either be a standard Java - * stream object or your own subclass that implements the standard - * interface. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException - { - setBinaryStream(parameterIndex, x, length); - } - - /** - * When a very large binary value is input to a LONGVARBINARY parameter, - * it may be more practical to send it via a java.io.InputStream. - * JDBC will read the data from the stream as needed, until it reaches - * end-of-file. - * - *

Note: This stream object can either be a standard Java - * stream object or your own subclass that implements the standard - * interface. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - /** - * In general, parameter values remain in force for repeated used of a - * Statement. Setting a parameter value automatically clears its - * previous value. However, in coms cases, it is useful to immediately - * release the resources used by the current parameter values; this - * can be done by calling clearParameters - * - * @exception SQLException if a database access error occurs - */ - public void clearParameters() throws SQLException - { - int i; - - for (i = 0 ; i < inStrings.length ; i++) - inStrings[i] = null; - } - - /** - * Set the value of a parameter using an object; use the java.lang - * equivalent objects for integral values. - * - *

The given Java object will be converted to the targetSqlType before - * being sent to the database. - * - *

note that this method may be used to pass database-specific - * abstract data types. This is done by using a Driver-specific - * Java type and using a targetSqlType of java.sql.Types.OTHER - * - * @param parameterIndex the first parameter is 1... - * @param x the object containing the input parameter value - * @param targetSqlType The SQL type to be send to the database - * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC - * types this is the number of digits after the decimal. For - * all other types this value will be ignored. - * @exception SQLException if a database access error occurs - */ - public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException - { - switch (targetSqlType) - { - case Types.TINYINT: - case Types.SMALLINT: - case Types.INTEGER: - case Types.BIGINT: - case Types.REAL: - case Types.FLOAT: - case Types.DOUBLE: - case Types.DECIMAL: - case Types.NUMERIC: - if (x instanceof Boolean) - set(parameterIndex, ((Boolean)x).booleanValue() ? "1" : "0"); - else - set(parameterIndex, x.toString()); - break; - case Types.CHAR: - case Types.VARCHAR: - case Types.LONGVARCHAR: - setString(parameterIndex, x.toString()); - break; - case Types.DATE: - setDate(parameterIndex, (java.sql.Date)x); - break; - case Types.TIME: - setTime(parameterIndex, (Time)x); - break; - case Types.TIMESTAMP: - setTimestamp(parameterIndex, (Timestamp)x); - break; - case Types.OTHER: - setString(parameterIndex, ((PGobject)x).getValue()); - break; - default: - throw new PSQLException("postgresql.prep.type"); - } - } - - public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException - { - setObject(parameterIndex, x, targetSqlType, 0); - } - - /** - * This stores an Object into a parameter. - *

New for 6.4, if the object is not recognised, but it is - * Serializable, then the object is serialised using the - * postgresql.util.Serialize class. - */ - public void setObject(int parameterIndex, Object x) throws SQLException - { - if (x instanceof String) - setString(parameterIndex, (String)x); - else if (x instanceof BigDecimal) - setBigDecimal(parameterIndex, (BigDecimal)x); - else if (x instanceof Short) - setShort(parameterIndex, ((Short)x).shortValue()); - else if (x instanceof Integer) - setInt(parameterIndex, ((Integer)x).intValue()); - else if (x instanceof Long) - setLong(parameterIndex, ((Long)x).longValue()); - else if (x instanceof Float) - setFloat(parameterIndex, ((Float)x).floatValue()); - else if (x instanceof Double) - setDouble(parameterIndex, ((Double)x).doubleValue()); - else if (x instanceof byte[]) - setBytes(parameterIndex, (byte[])x); - else if (x instanceof java.sql.Date) - setDate(parameterIndex, (java.sql.Date)x); - else if (x instanceof Time) - setTime(parameterIndex, (Time)x); - else if (x instanceof Timestamp) - setTimestamp(parameterIndex, (Timestamp)x); - else if (x instanceof Boolean) - setBoolean(parameterIndex, ((Boolean)x).booleanValue()); - else if (x instanceof PGobject) - setString(parameterIndex, ((PGobject)x).getValue()); - else - setLong(parameterIndex, connection.putObject(x)); - } - - /** - * Some prepared statements return multiple results; the execute method - * handles these complex statements as well as the simpler form of - * statements handled by executeQuery and executeUpdate - * - * @return true if the next result is a ResultSet; false if it is an - * update count or there are no more results - * @exception SQLException if a database access error occurs - */ - public boolean execute() throws SQLException - { - StringBuffer s = new StringBuffer(); - int i; - - for (i = 0 ; i < inStrings.length ; ++i) - { - if (inStrings[i] == null) - throw new PSQLException("postgresql.prep.param",new Integer(i + 1)); - s.append (templateStrings[i]); - s.append (inStrings[i]); - } - s.append(templateStrings[inStrings.length]); - return super.execute(s.toString()); // in Statement class - } - - /** - * Returns the SQL statement with the current template values - * substituted. - */ - public String toString() { - StringBuffer s = new StringBuffer(); - int i; - - for (i = 0 ; i < inStrings.length ; ++i) - { - if (inStrings[i] == null) - s.append( '?' ); - else - s.append (templateStrings[i]); - s.append (inStrings[i]); - } - s.append(templateStrings[inStrings.length]); - return s.toString(); - } - - // ************************************************************** - // END OF PUBLIC INTERFACE - // ************************************************************** - - /** - * There are a lot of setXXX classes which all basically do - * the same thing. We need a method which actually does the - * set for us. - * - * @param paramIndex the index into the inString - * @param s a string to be stored - * @exception SQLException if something goes wrong - */ - private void set(int paramIndex, String s) throws SQLException - { - if (paramIndex < 1 || paramIndex > inStrings.length) - throw new PSQLException("postgresql.prep.range"); - inStrings[paramIndex - 1] = s; - } -} diff --git a/src/interfaces/jdbc/postgresql/jdbc1/ResultSet.java b/src/interfaces/jdbc/postgresql/jdbc1/ResultSet.java deleted file mode 100644 index e28f5a6132..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc1/ResultSet.java +++ /dev/null @@ -1,768 +0,0 @@ -package postgresql.jdbc1; - -// IMPORTANT NOTE: This file implements the JDBC 1 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 2 class in the -// postgresql.jdbc2 package. - -import java.lang.*; -import java.io.*; -import java.math.*; -import java.text.*; -import java.util.*; -import java.sql.*; -import postgresql.Field; -import postgresql.largeobject.*; -import postgresql.util.*; - -/** - * A ResultSet provides access to a table of data generated by executing a - * Statement. The table rows are retrieved in sequence. Within a row its - * column values can be accessed in any order. - * - *

A ResultSet maintains a cursor pointing to its current row of data. - * Initially the cursor is positioned before the first row. The 'next' - * method moves the cursor to the next row. - * - *

The getXXX methods retrieve column values for the current row. You can - * retrieve values either using the index number of the column, or by using - * the name of the column. In general using the column index will be more - * efficient. Columns are numbered from 1. - * - *

For maximum portability, ResultSet columns within each row should be read - * in left-to-right order and each column should be read only once. - * - *

For the getXXX methods, the JDBC driver attempts to convert the - * underlying data to the specified Java type and returns a suitable Java - * value. See the JDBC specification for allowable mappings from SQL types - * to Java types with the ResultSet getXXX methods. - * - *

Column names used as input to getXXX methods are case insenstive. When - * performing a getXXX using a column name, if several columns have the same - * name, then the value of the first matching column will be returned. The - * column name option is designed to be used when column names are used in the - * SQL Query. For columns that are NOT explicitly named in the query, it is - * best to use column numbers. If column names were used there is no way for - * the programmer to guarentee that they actually refer to the intended - * columns. - * - *

A ResultSet is automatically closed by the Statement that generated it - * when that Statement is closed, re-executed, or is used to retrieve the - * next result from a sequence of multiple results. - * - *

The number, types and properties of a ResultSet's columns are provided by - * the ResultSetMetaData object returned by the getMetaData method. - * - * @see ResultSetMetaData - * @see java.sql.ResultSet - */ -public class ResultSet extends postgresql.ResultSet implements java.sql.ResultSet -{ - /** - * Create a new ResultSet - Note that we create ResultSets to - * represent the results of everything. - * - * @param fields an array of Field objects (basically, the - * ResultSet MetaData) - * @param tuples Vector of the actual data - * @param status the status string returned from the back end - * @param updateCount the number of rows affected by the operation - * @param cursor the positioned update/delete cursor name - */ - public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount) - { - super(conn,fields,tuples,status,updateCount); - } - - /** - * A ResultSet is initially positioned before its first row, - * the first call to next makes the first row the current row; - * the second call makes the second row the current row, etc. - * - *

If an input stream from the previous row is open, it is - * implicitly closed. The ResultSet's warning chain is cleared - * when a new row is read - * - * @return true if the new current is valid; false if there are no - * more rows - * @exception SQLException if a database access error occurs - */ - public boolean next() throws SQLException - { - if (++current_row >= rows.size()) - return false; - this_row = (byte [][])rows.elementAt(current_row); - return true; - } - - /** - * In some cases, it is desirable to immediately release a ResultSet - * database and JDBC resources instead of waiting for this to happen - * when it is automatically closed. The close method provides this - * immediate release. - * - *

Note: A ResultSet is automatically closed by the Statement - * the Statement that generated it when that Statement is closed, - * re-executed, or is used to retrieve the next result from a sequence - * of multiple results. A ResultSet is also automatically closed - * when it is garbage collected. - * - * @exception SQLException if a database access error occurs - */ - public void close() throws SQLException - { - // No-op - } - - /** - * A column may have the value of SQL NULL; wasNull() reports whether - * the last column read had this special value. Note that you must - * first call getXXX on a column to try to read its value and then - * call wasNull() to find if the value was SQL NULL - * - * @return true if the last column read was SQL NULL - * @exception SQLException if a database access error occurred - */ - public boolean wasNull() throws SQLException - { - return wasNullFlag; - } - - /** - * Get the value of a column in the current row as a Java String - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value, null for SQL NULL - * @exception SQLException if a database access error occurs - */ - public String getString(int columnIndex) throws SQLException - { - //byte[] bytes = getBytes(columnIndex); - // - //if (bytes == null) - //return null; - //return new String(bytes); - if (columnIndex < 1 || columnIndex > fields.length) - throw new PSQLException("postgresql.res.colrange"); - wasNullFlag = (this_row[columnIndex - 1] == null); - if(wasNullFlag) - return null; - return new String(this_row[columnIndex - 1]); - } - - /** - * Get the value of a column in the current row as a Java boolean - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value, false for SQL NULL - * @exception SQLException if a database access error occurs - */ - public boolean getBoolean(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - int c = s.charAt(0); - return ((c == 't') || (c == 'T')); - } - return false; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java byte. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public byte getByte(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Byte.parseByte(s); - } catch (NumberFormatException e) { - throw new PSQLException("postgresql.res.badbyte",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java short. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public short getShort(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Short.parseShort(s); - } catch (NumberFormatException e) { - throw new PSQLException("postgresql.res.badshort",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java int. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public int getInt(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Integer.parseInt(s); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.badint",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java long. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public long getLong(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Long.parseLong(s); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.badlong",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java float. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public float getFloat(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Float.valueOf(s).floatValue(); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.badfloat",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java double. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public double getDouble(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Double.valueOf(s).doubleValue(); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.baddouble",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a - * java.math.BigDecimal object - * - * @param columnIndex the first column is 1, the second is 2... - * @param scale the number of digits to the right of the decimal - * @return the column value; if the value is SQL NULL, null - * @exception SQLException if a database access error occurs - */ - public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException - { - String s = getString(columnIndex); - BigDecimal val; - - if (s != null) - { - try - { - val = new BigDecimal(s); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.badbigdec",s); - } - try - { - return val.setScale(scale); - } catch (ArithmeticException e) { - throw new PSQLException ("postgresql.res.badbigdec",s); - } - } - return null; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java byte array. - * - *

In normal use, the bytes represent the raw values returned by the - * backend. However, if the column is an OID, then it is assumed to - * refer to a Large Object, and that object is returned as a byte array. - * - *

Be warned If the large object is huge, then you may run out - * of memory. - * - * @param columnIndex the first column is 1, the second is 2, ... - * @return the column value; if the value is SQL NULL, the result - * is null - * @exception SQLException if a database access error occurs - */ - public byte[] getBytes(int columnIndex) throws SQLException - { - if (columnIndex < 1 || columnIndex > fields.length) - throw new PSQLException("postgresql.res.colrange"); - wasNullFlag = (this_row[columnIndex - 1] == null); - - // Handle OID's as BLOBS - if(!wasNullFlag) - if( fields[columnIndex - 1].getOID() == 26) { - LargeObjectManager lom = connection.getLargeObjectAPI(); - LargeObject lob = lom.open(getInt(columnIndex)); - byte buf[] = lob.read(lob.size()); - lob.close(); - return buf; - } - - return this_row[columnIndex - 1]; - } - - /** - * Get the value of a column in the current row as a java.sql.Date - * object - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value; null if SQL NULL - * @exception SQLException if a database access error occurs - */ - public java.sql.Date getDate(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - if(s==null) - return null; - SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); - try { - return new java.sql.Date(df.parse(s).getTime()); - } catch (ParseException e) { - throw new PSQLException("postgresql.res.baddate",new Integer(e.getErrorOffset()),s); - } - } - - /** - * Get the value of a column in the current row as a java.sql.Time - * object - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value; null if SQL NULL - * @exception SQLException if a database access error occurs - */ - public Time getTime(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - if (s.length() != 5 && s.length() != 8) - throw new NumberFormatException("Wrong Length!"); - int hr = Integer.parseInt(s.substring(0,2)); - int min = Integer.parseInt(s.substring(3,5)); - int sec = (s.length() == 5) ? 0 : Integer.parseInt(s.substring(6)); - return new Time(hr, min, sec); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.badtime",s); - } - } - return null; // SQL NULL - } - - /** - * Get the value of a column in the current row as a - * java.sql.Timestamp object - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value; null if SQL NULL - * @exception SQLException if a database access error occurs - */ - public Timestamp getTimestamp(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - if(s==null) - return null; - - SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:sszzz"); - - try { - return new Timestamp(df.parse(s).getTime()); - } catch(ParseException e) { - throw new PSQLException("postgresql.res.badtimestamp",new Integer(e.getErrorOffset()),s); - } - } - - /** - * A column value can be retrieved as a stream of ASCII characters - * and then read in chunks from the stream. This method is - * particular suitable for retrieving large LONGVARCHAR values. - * The JDBC driver will do any necessary conversion from the - * database format into ASCII. - * - *

Note: All the data in the returned stream must be read - * prior to getting the value of any other column. The next call - * to a get method implicitly closes the stream. Also, a stream - * may return 0 for available() whether there is data available - * or not. - * - *

We implement an ASCII stream as a Binary stream - we should really - * do the data conversion, but I cannot be bothered to implement this - * right now. - * - * @param columnIndex the first column is 1, the second is 2, ... - * @return a Java InputStream that delivers the database column - * value as a stream of one byte ASCII characters. If the - * value is SQL NULL then the result is null - * @exception SQLException if a database access error occurs - * @see getBinaryStream - */ - public InputStream getAsciiStream(int columnIndex) throws SQLException - { - return getBinaryStream(columnIndex); - } - - /** - * A column value can also be retrieved as a stream of Unicode - * characters. We implement this as a binary stream. - * - * @param columnIndex the first column is 1, the second is 2... - * @return a Java InputStream that delivers the database column value - * as a stream of two byte Unicode characters. If the value is - * SQL NULL, then the result is null - * @exception SQLException if a database access error occurs - * @see getAsciiStream - * @see getBinaryStream - */ - public InputStream getUnicodeStream(int columnIndex) throws SQLException - { - return getBinaryStream(columnIndex); - } - - /** - * A column value can also be retrieved as a binary strea. This - * method is suitable for retrieving LONGVARBINARY values. - * - * @param columnIndex the first column is 1, the second is 2... - * @return a Java InputStream that delivers the database column value - * as a stream of bytes. If the value is SQL NULL, then the result - * is null - * @exception SQLException if a database access error occurs - * @see getAsciiStream - * @see getUnicodeStream - */ - public InputStream getBinaryStream(int columnIndex) throws SQLException - { - byte b[] = getBytes(columnIndex); - - if (b != null) - return new ByteArrayInputStream(b); - return null; // SQL NULL - } - - /** - * The following routines simply convert the columnName into - * a columnIndex and then call the appropriate routine above. - * - * @param columnName is the SQL name of the column - * @return the column value - * @exception SQLException if a database access error occurs - */ - public String getString(String columnName) throws SQLException - { - return getString(findColumn(columnName)); - } - - public boolean getBoolean(String columnName) throws SQLException - { - return getBoolean(findColumn(columnName)); - } - - public byte getByte(String columnName) throws SQLException - { - - return getByte(findColumn(columnName)); - } - - public short getShort(String columnName) throws SQLException - { - return getShort(findColumn(columnName)); - } - - public int getInt(String columnName) throws SQLException - { - return getInt(findColumn(columnName)); - } - - public long getLong(String columnName) throws SQLException - { - return getLong(findColumn(columnName)); - } - - public float getFloat(String columnName) throws SQLException - { - return getFloat(findColumn(columnName)); - } - - public double getDouble(String columnName) throws SQLException - { - return getDouble(findColumn(columnName)); - } - - public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException - { - return getBigDecimal(findColumn(columnName), scale); - } - - public byte[] getBytes(String columnName) throws SQLException - { - return getBytes(findColumn(columnName)); - } - - public java.sql.Date getDate(String columnName) throws SQLException - { - return getDate(findColumn(columnName)); - } - - public Time getTime(String columnName) throws SQLException - { - return getTime(findColumn(columnName)); - } - - public Timestamp getTimestamp(String columnName) throws SQLException - { - return getTimestamp(findColumn(columnName)); - } - - public InputStream getAsciiStream(String columnName) throws SQLException - { - return getAsciiStream(findColumn(columnName)); - } - - public InputStream getUnicodeStream(String columnName) throws SQLException - { - return getUnicodeStream(findColumn(columnName)); - } - - public InputStream getBinaryStream(String columnName) throws SQLException - { - return getBinaryStream(findColumn(columnName)); - } - - /** - * The first warning reported by calls on this ResultSet is - * returned. Subsequent ResultSet warnings will be chained - * to this SQLWarning. - * - *

The warning chain is automatically cleared each time a new - * row is read. - * - *

Note: This warning chain only covers warnings caused by - * ResultSet methods. Any warnings caused by statement methods - * (such as reading OUT parameters) will be chained on the - * Statement object. - * - * @return the first SQLWarning or null; - * @exception SQLException if a database access error occurs. - */ - public SQLWarning getWarnings() throws SQLException - { - return warnings; - } - - /** - * After this call, getWarnings returns null until a new warning - * is reported for this ResultSet - * - * @exception SQLException if a database access error occurs - */ - public void clearWarnings() throws SQLException - { - warnings = null; - } - - /** - * Get the name of the SQL cursor used by this ResultSet - * - *

In SQL, a result table is retrieved though a cursor that is - * named. The current row of a result can be updated or deleted - * using a positioned update/delete statement that references - * the cursor name. - * - *

JDBC supports this SQL feature by providing the name of the - * SQL cursor used by a ResultSet. The current row of a ResulSet - * is also the current row of this SQL cursor. - * - *

Note: If positioned update is not supported, a SQLException - * is thrown. - * - * @return the ResultSet's SQL cursor name. - * @exception SQLException if a database access error occurs - */ - public String getCursorName() throws SQLException - { - return connection.getCursorName(); - } - - /** - * The numbers, types and properties of a ResultSet's columns are - * provided by the getMetaData method - * - * @return a description of the ResultSet's columns - * @exception SQLException if a database access error occurs - */ - public java.sql.ResultSetMetaData getMetaData() throws SQLException - { - return new ResultSetMetaData(rows, fields); - } - - /** - * Get the value of a column in the current row as a Java object - * - *

This method will return the value of the given column as a - * Java object. The type of the Java object will be the default - * Java Object type corresponding to the column's SQL type, following - * the mapping specified in the JDBC specification. - * - *

This method may also be used to read database specific abstract - * data types. - * - * @param columnIndex the first column is 1, the second is 2... - * @return a Object holding the column value - * @exception SQLException if a database access error occurs - */ - public Object getObject(int columnIndex) throws SQLException - { - Field field; - - if (columnIndex < 1 || columnIndex > fields.length) - throw new PSQLException("postgresql.res.colrange"); - field = fields[columnIndex - 1]; - - // some fields can be null, mainly from those returned by MetaData methods - if(field==null) { - wasNullFlag=true; - return null; - } - - switch (field.getSQLType()) - { - case Types.BIT: - return new Boolean(getBoolean(columnIndex)); - case Types.SMALLINT: - return new Integer(getInt(columnIndex)); - case Types.INTEGER: - return new Integer(getInt(columnIndex)); - case Types.BIGINT: - return new Long(getLong(columnIndex)); - case Types.NUMERIC: - return getBigDecimal(columnIndex, ((field.mod-4) & 0xffff)); - case Types.REAL: - return new Float(getFloat(columnIndex)); - case Types.DOUBLE: - return new Double(getDouble(columnIndex)); - case Types.CHAR: - case Types.VARCHAR: - return getString(columnIndex); - case Types.DATE: - return getDate(columnIndex); - case Types.TIME: - return getTime(columnIndex); - case Types.TIMESTAMP: - return getTimestamp(columnIndex); - default: - return connection.getObject(field.getTypeName(), getString(columnIndex)); - } - } - - /** - * Get the value of a column in the current row as a Java object - * - *

This method will return the value of the given column as a - * Java object. The type of the Java object will be the default - * Java Object type corresponding to the column's SQL type, following - * the mapping specified in the JDBC specification. - * - *

This method may also be used to read database specific abstract - * data types. - * - * @param columnName is the SQL name of the column - * @return a Object holding the column value - * @exception SQLException if a database access error occurs - */ - public Object getObject(String columnName) throws SQLException - { - return getObject(findColumn(columnName)); - } - - /** - * Map a ResultSet column name to a ResultSet column index - * - * @param columnName the name of the column - * @return the column index - * @exception SQLException if a database access error occurs - */ - public int findColumn(String columnName) throws SQLException - { - int i; - - for (i = 0 ; i < fields.length; ++i) - if (fields[i].name.equalsIgnoreCase(columnName)) - return (i+1); - throw new PSQLException ("postgresql.res.colname",columnName); - } -} - diff --git a/src/interfaces/jdbc/postgresql/jdbc1/ResultSetMetaData.java b/src/interfaces/jdbc/postgresql/jdbc1/ResultSetMetaData.java deleted file mode 100644 index a5859e3dd8..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc1/ResultSetMetaData.java +++ /dev/null @@ -1,451 +0,0 @@ -package postgresql.jdbc1; - -// IMPORTANT NOTE: This file implements the JDBC 1 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 2 class in the -// postgresql.jdbc2 package. - -import java.lang.*; -import java.util.*; -import postgresql.*; -import postgresql.util.*; - -// We explicitly import classes here as the original line: -//import java.sql.*; -// causes javac to get confused. -import java.sql.SQLException; -import java.sql.Types; - -/** - * A ResultSetMetaData object can be used to find out about the types and - * properties of the columns in a ResultSet - * - * @see java.sql.ResultSetMetaData - */ -public class ResultSetMetaData implements java.sql.ResultSetMetaData -{ - Vector rows; - Field[] fields; - - /** - * Initialise for a result with a tuple set and - * a field descriptor set - * - * @param rows the Vector of rows returned by the ResultSet - * @param fields the array of field descriptors - */ - public ResultSetMetaData(Vector rows, Field[] fields) - { - this.rows = rows; - this.fields = fields; - } - - /** - * Whats the number of columns in the ResultSet? - * - * @return the number - * @exception SQLException if a database access error occurs - */ - public int getColumnCount() throws SQLException - { - return fields.length; - } - - /** - * Is the column automatically numbered (and thus read-only) - * I believe that PostgreSQL does not support this feature. - * - * @param column the first column is 1, the second is 2... - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isAutoIncrement(int column) throws SQLException - { - return false; - } - - /** - * Does a column's case matter? ASSUMPTION: Any field that is - * not obviously case insensitive is assumed to be case sensitive - * - * @param column the first column is 1, the second is 2... - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isCaseSensitive(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - switch (sql_type) - { - case Types.SMALLINT: - case Types.INTEGER: - case Types.FLOAT: - case Types.REAL: - case Types.DOUBLE: - case Types.DATE: - case Types.TIME: - case Types.TIMESTAMP: - return false; - default: - return true; - } - } - - /** - * Can the column be used in a WHERE clause? Basically for - * this, I split the functions into two types: recognised - * types (which are always useable), and OTHER types (which - * may or may not be useable). The OTHER types, for now, I - * will assume they are useable. We should really query the - * catalog to see if they are useable. - * - * @param column the first column is 1, the second is 2... - * @return true if they can be used in a WHERE clause - * @exception SQLException if a database access error occurs - */ - public boolean isSearchable(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - // This switch is pointless, I know - but it is a set-up - // for further expansion. - switch (sql_type) - { - case Types.OTHER: - return true; - default: - return true; - } - } - - /** - * Is the column a cash value? 6.1 introduced the cash/money - * type, which haven't been incorporated as of 970414, so I - * just check the type name for both 'cash' and 'money' - * - * @param column the first column is 1, the second is 2... - * @return true if its a cash column - * @exception SQLException if a database access error occurs - */ - public boolean isCurrency(int column) throws SQLException - { - String type_name = getField(column).getTypeName(); - - return type_name.equals("cash") || type_name.equals("money"); - } - - /** - * Can you put a NULL in this column? I think this is always - * true in 6.1's case. It would only be false if the field had - * been defined NOT NULL (system catalogs could be queried?) - * - * @param column the first column is 1, the second is 2... - * @return one of the columnNullable values - * @exception SQLException if a database access error occurs - */ - public int isNullable(int column) throws SQLException - { - return columnNullable; // We can always put NULL in - } - - /** - * Is the column a signed number? In PostgreSQL, all numbers - * are signed, so this is trivial. However, strings are not - * signed (duh!) - * - * @param column the first column is 1, the second is 2... - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isSigned(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - switch (sql_type) - { - case Types.SMALLINT: - case Types.INTEGER: - case Types.FLOAT: - case Types.REAL: - case Types.DOUBLE: - return true; - case Types.DATE: - case Types.TIME: - case Types.TIMESTAMP: - return false; // I don't know about these? - default: - return false; - } - } - - /** - * What is the column's normal maximum width in characters? - * - * @param column the first column is 1, the second is 2, etc. - * @return the maximum width - * @exception SQLException if a database access error occurs - */ - public int getColumnDisplaySize(int column) throws SQLException - { - Field f = getField(column); - String type_name = f.getTypeName(); - int sql_type = f.getSQLType(); - int typmod = f.mod; - - // I looked at other JDBC implementations and couldn't find a consistent - // interpretation of the "display size" for numeric values, so this is our's - // FIXME: currently, only types with a SQL92 or SQL3 pendant are implemented - jens@jens.de - - // fixed length data types - if (type_name.equals( "int2" )) return 6; // -32768 to +32768 (5 digits and a sign) - if (type_name.equals( "int4" ) - || type_name.equals( "oid" )) return 11; // -2147483648 to +2147483647 - if (type_name.equals( "int8" )) return 20; // -9223372036854775808 to +9223372036854775807 - if (type_name.equals( "money" )) return 12; // MONEY = DECIMAL(9,2) - if (type_name.equals( "float4" )) return 11; // i checked it out ans wasn't able to produce more than 11 digits - if (type_name.equals( "float8" )) return 20; // dito, 20 - if (type_name.equals( "char" )) return 1; - if (type_name.equals( "bool" )) return 1; - if (type_name.equals( "date" )) return 14; // "01/01/4713 BC" - "31/12/32767 AD" - if (type_name.equals( "time" )) return 8; // 00:00:00-23:59:59 - if (type_name.equals( "timestamp" )) return 22; // hhmmm ... the output looks like this: 1999-08-03 22:22:08+02 - - // variable length fields - typmod -= 4; - if (type_name.equals( "bpchar" ) - || type_name.equals( "varchar" )) return typmod; // VARHDRSZ=sizeof(int32)=4 - if (type_name.equals( "numeric" )) return ( (typmod >>16) & 0xffff ) - + 1 + ( typmod & 0xffff ); // DECIMAL(p,s) = (p digits).(s digits) - - // if we don't know better - return f.length; - } - - /** - * What is the suggested column title for use in printouts and - * displays? We suggest the ColumnName! - * - * @param column the first column is 1, the second is 2, etc. - * @return the column label - * @exception SQLException if a database access error occurs - */ - public String getColumnLabel(int column) throws SQLException - { - return getColumnName(column); - } - - /** - * What's a column's name? - * - * @param column the first column is 1, the second is 2, etc. - * @return the column name - * @exception SQLException if a database access error occurs - */ - public String getColumnName(int column) throws SQLException - { - Field f = getField(column); - if(f!=null) - return f.name; - return "field"+column; - } - - /** - * What is a column's table's schema? This relies on us knowing - * the table name....which I don't know how to do as yet. The - * JDBC specification allows us to return "" if this is not - * applicable. - * - * @param column the first column is 1, the second is 2... - * @return the Schema - * @exception SQLException if a database access error occurs - */ - public String getSchemaName(int column) throws SQLException - { - return ""; - } - - /** - * What is a column's number of decimal digits. - * - * @param column the first column is 1, the second is 2... - * @return the precision - * @exception SQLException if a database access error occurs - */ - public int getPrecision(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - switch (sql_type) - { - case Types.SMALLINT: - return 5; - case Types.INTEGER: - return 10; - case Types.REAL: - return 8; - case Types.FLOAT: - return 16; - case Types.DOUBLE: - return 16; - case Types.VARCHAR: - return 0; - default: - return 0; - } - } - - /** - * What is a column's number of digits to the right of the - * decimal point? - * - * @param column the first column is 1, the second is 2... - * @return the scale - * @exception SQLException if a database access error occurs - */ - public int getScale(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - switch (sql_type) - { - case Types.SMALLINT: - return 0; - case Types.INTEGER: - return 0; - case Types.REAL: - return 8; - case Types.FLOAT: - return 16; - case Types.DOUBLE: - return 16; - case Types.VARCHAR: - return 0; - default: - return 0; - } - } - - /** - * Whats a column's table's name? How do I find this out? Both - * getSchemaName() and getCatalogName() rely on knowing the table - * Name, so we need this before we can work on them. - * - * @param column the first column is 1, the second is 2... - * @return column name, or "" if not applicable - * @exception SQLException if a database access error occurs - */ - public String getTableName(int column) throws SQLException - { - return ""; - } - - /** - * What's a column's table's catalog name? As with getSchemaName(), - * we can say that if getTableName() returns n/a, then we can too - - * otherwise, we need to work on it. - * - * @param column the first column is 1, the second is 2... - * @return catalog name, or "" if not applicable - * @exception SQLException if a database access error occurs - */ - public String getCatalogName(int column) throws SQLException - { - return ""; - } - - /** - * What is a column's SQL Type? (java.sql.Type int) - * - * @param column the first column is 1, the second is 2, etc. - * @return the java.sql.Type value - * @exception SQLException if a database access error occurs - * @see postgresql.Field#getSQLType - * @see java.sql.Types - */ - public int getColumnType(int column) throws SQLException - { - return getField(column).getSQLType(); - } - - /** - * Whats is the column's data source specific type name? - * - * @param column the first column is 1, the second is 2, etc. - * @return the type name - * @exception SQLException if a database access error occurs - */ - public String getColumnTypeName(int column) throws SQLException - { - return getField(column).getTypeName(); - } - - /** - * Is the column definitely not writable? In reality, we would - * have to check the GRANT/REVOKE stuff for this to be effective, - * and I haven't really looked into that yet, so this will get - * re-visited. - * - * @param column the first column is 1, the second is 2, etc. - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isReadOnly(int column) throws SQLException - { - return false; - } - - /** - * Is it possible for a write on the column to succeed? Again, we - * would in reality have to check the GRANT/REVOKE stuff, which - * I haven't worked with as yet. However, if it isn't ReadOnly, then - * it is obviously writable. - * - * @param column the first column is 1, the second is 2, etc. - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isWritable(int column) throws SQLException - { - if (isReadOnly(column)) - return true; - else - return false; - } - - /** - * Will a write on this column definately succeed? Hmmm...this - * is a bad one, since the two preceding functions have not been - * really defined. I cannot tell is the short answer. I thus - * return isWritable() just to give us an idea. - * - * @param column the first column is 1, the second is 2, etc.. - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isDefinitelyWritable(int column) throws SQLException - { - return isWritable(column); - } - - // ******************************************************** - // END OF PUBLIC INTERFACE - // ******************************************************** - - /** - * For several routines in this package, we need to convert - * a columnIndex into a Field[] descriptor. Rather than do - * the same code several times, here it is. - * - * @param columnIndex the first column is 1, the second is 2... - * @return the Field description - * @exception SQLException if a database access error occurs - */ - private Field getField(int columnIndex) throws SQLException - { - if (columnIndex < 1 || columnIndex > fields.length) - throw new PSQLException("postgresql.res.colrange"); - return fields[columnIndex - 1]; - } -} - diff --git a/src/interfaces/jdbc/postgresql/jdbc1/Statement.java b/src/interfaces/jdbc/postgresql/jdbc1/Statement.java deleted file mode 100644 index 0f458acec7..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc1/Statement.java +++ /dev/null @@ -1,325 +0,0 @@ -package postgresql.jdbc1; - -// IMPORTANT NOTE: This file implements the JDBC 1 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 2 class in the -// postgresql.jdbc2 package. - -import java.sql.*; - -import postgresql.util.PSQLException; - -/** - * A Statement object is used for executing a static SQL statement and - * obtaining the results produced by it. - * - *

Only one ResultSet per Statement can be open at any point in time. - * Therefore, if the reading of one ResultSet is interleaved with the - * reading of another, each must have been generated by different - * Statements. All statement execute methods implicitly close a - * statement's current ResultSet if an open one exists. - * - * @see java.sql.Statement - * @see ResultSet - */ -public class Statement implements java.sql.Statement -{ - Connection connection; // The connection who created us - java.sql.ResultSet result = null; // The current results - SQLWarning warnings = null; // The warnings chain. - int timeout = 0; // The timeout for a query (not used) - boolean escapeProcessing = true;// escape processing flag - - /** - * Constructor for a Statement. It simply sets the connection - * that created us. - * - * @param c the Connection instantation that creates us - */ - public Statement (Connection c) - { - connection = c; - } - - /** - * Execute a SQL statement that retruns a single ResultSet - * - * @param sql typically a static SQL SELECT statement - * @return a ResulSet that contains the data produced by the query - * @exception SQLException if a database access error occurs - */ - public java.sql.ResultSet executeQuery(String sql) throws SQLException - { - this.execute(sql); - while (result != null && !((postgresql.ResultSet)result).reallyResultSet()) - result = ((postgresql.ResultSet)result).getNext(); - if (result == null) - throw new PSQLException("postgresql.stat.noresult"); - return result; - } - - /** - * Execute a SQL INSERT, UPDATE or DELETE statement. In addition - * SQL statements that return nothing such as SQL DDL statements - * can be executed - * - * @param sql a SQL statement - * @return either a row count, or 0 for SQL commands - * @exception SQLException if a database access error occurs - */ - public int executeUpdate(String sql) throws SQLException - { - this.execute(sql); - if (((postgresql.ResultSet)result).reallyResultSet()) - throw new PSQLException("postgresql.stat.result"); - return this.getUpdateCount(); - } - - /** - * In many cases, it is desirable to immediately release a - * Statement's database and JDBC resources instead of waiting - * for this to happen when it is automatically closed. The - * close method provides this immediate release. - * - *

Note: A Statement is automatically closed when it is - * garbage collected. When a Statement is closed, its current - * ResultSet, if one exists, is also closed. - * - * @exception SQLException if a database access error occurs (why?) - */ - public void close() throws SQLException - { - result = null; - } - - /** - * The maxFieldSize limit (in bytes) is the maximum amount of - * data returned for any column value; it only applies to - * BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR and LONGVARCHAR - * columns. If the limit is exceeded, the excess data is silently - * discarded. - * - * @return the current max column size limit; zero means unlimited - * @exception SQLException if a database access error occurs - */ - public int getMaxFieldSize() throws SQLException - { - return 8192; // We cannot change this - } - - /** - * Sets the maxFieldSize - NOT! - We throw an SQLException just - * to inform them to stop doing this. - * - * @param max the new max column size limit; zero means unlimited - * @exception SQLException if a database access error occurs - */ - public void setMaxFieldSize(int max) throws SQLException - { - throw new PSQLException("postgresql.stat.maxfieldsize"); - } - - /** - * The maxRows limit is set to limit the number of rows that - * any ResultSet can contain. If the limit is exceeded, the - * excess rows are silently dropped. - * - * @return the current maximum row limit; zero means unlimited - * @exception SQLException if a database access error occurs - */ - public int getMaxRows() throws SQLException - { - return connection.maxrows; - } - - /** - * Set the maximum number of rows - * - * @param max the new max rows limit; zero means unlimited - * @exception SQLException if a database access error occurs - * @see getMaxRows - */ - public void setMaxRows(int max) throws SQLException - { - connection.maxrows = max; - } - - /** - * If escape scanning is on (the default), the driver will do escape - * substitution before sending the SQL to the database. - * - * @param enable true to enable; false to disable - * @exception SQLException if a database access error occurs - */ - public void setEscapeProcessing(boolean enable) throws SQLException - { - escapeProcessing = enable; - } - - /** - * The queryTimeout limit is the number of seconds the driver - * will wait for a Statement to execute. If the limit is - * exceeded, a SQLException is thrown. - * - * @return the current query timeout limit in seconds; 0 = unlimited - * @exception SQLException if a database access error occurs - */ - public int getQueryTimeout() throws SQLException - { - return timeout; - } - - /** - * Sets the queryTimeout limit - * - * @param seconds - the new query timeout limit in seconds - * @exception SQLException if a database access error occurs - */ - public void setQueryTimeout(int seconds) throws SQLException - { - timeout = seconds; - } - - /** - * Cancel can be used by one thread to cancel a statement that - * is being executed by another thread. However, PostgreSQL is - * a sync. sort of thing, so this really has no meaning - we - * define it as a no-op (i.e. you can't cancel, but there is no - * error if you try.) - * - * 6.4 introduced a cancel operation, but we have not implemented it - * yet. Sometime before 6.5, this method will be implemented. - * - * @exception SQLException only because thats the spec. - */ - public void cancel() throws SQLException - { - // No-op - } - - /** - * The first warning reported by calls on this Statement is - * returned. A Statement's execute methods clear its SQLWarning - * chain. Subsequent Statement warnings will be chained to this - * SQLWarning. - * - *

The Warning chain is automatically cleared each time a statement - * is (re)executed. - * - *

Note: If you are processing a ResultSet then any warnings - * associated with ResultSet reads will be chained on the ResultSet - * object. - * - * @return the first SQLWarning on null - * @exception SQLException if a database access error occurs - */ - public SQLWarning getWarnings() throws SQLException - { - return warnings; - } - - /** - * After this call, getWarnings returns null until a new warning - * is reported for this Statement. - * - * @exception SQLException if a database access error occurs (why?) - */ - public void clearWarnings() throws SQLException - { - warnings = null; - } - - /** - * setCursorName defines the SQL cursor name that will be used by - * subsequent execute methods. This name can then be used in SQL - * positioned update/delete statements to identify the current row - * in the ResultSet generated by this statement. If a database - * doesn't support positioned update/delete, this method is a - * no-op. - * - *

Note: By definition, positioned update/delete execution - * must be done by a different Statement than the one which - * generated the ResultSet being used for positioning. Also, cursor - * names must be unique within a Connection. - * - *

We throw an additional constriction. There can only be one - * cursor active at any one time. - * - * @param name the new cursor name - * @exception SQLException if a database access error occurs - */ - public void setCursorName(String name) throws SQLException - { - connection.setCursorName(name); - } - - /** - * Execute a SQL statement that may return multiple results. We - * don't have to worry about this since we do not support multiple - * ResultSets. You can use getResultSet or getUpdateCount to - * retrieve the result. - * - * @param sql any SQL statement - * @return true if the next result is a ResulSet, false if it is - * an update count or there are no more results - * @exception SQLException if a database access error occurs - */ - public boolean execute(String sql) throws SQLException - { - result = connection.ExecSQL(sql); - return (result != null && ((postgresql.ResultSet)result).reallyResultSet()); - } - - /** - * getResultSet returns the current result as a ResultSet. It - * should only be called once per result. - * - * @return the current result set; null if there are no more - * @exception SQLException if a database access error occurs (why?) - */ - public java.sql.ResultSet getResultSet() throws SQLException - { - return result; - } - - /** - * getUpdateCount returns the current result as an update count, - * if the result is a ResultSet or there are no more results, -1 - * is returned. It should only be called once per result. - * - * @return the current result as an update count. - * @exception SQLException if a database access error occurs - */ - public int getUpdateCount() throws SQLException - { - if (result == null) return -1; - if (((postgresql.ResultSet)result).reallyResultSet()) return -1; - return ((postgresql.ResultSet)result).getResultCount(); - } - - /** - * getMoreResults moves to a Statement's next result. If it returns - * true, this result is a ResulSet. - * - * @return true if the next ResultSet is valid - * @exception SQLException if a database access error occurs - */ - public boolean getMoreResults() throws SQLException - { - result = ((postgresql.ResultSet)result).getNext(); - return (result != null && ((postgresql.ResultSet)result).reallyResultSet()); - } - - /** - * Returns the status message from the current Result.

- * This is used internally by the driver. - * - * @return status message from backend - */ - public String getResultStatusString() - { - if(result == null) - return null; - return ((postgresql.ResultSet)result).getStatusString(); - } -} diff --git a/src/interfaces/jdbc/postgresql/jdbc2/CallableStatement.java b/src/interfaces/jdbc/postgresql/jdbc2/CallableStatement.java deleted file mode 100644 index 6cbc2ef148..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc2/CallableStatement.java +++ /dev/null @@ -1,361 +0,0 @@ -package postgresql.jdbc2; - -// IMPORTANT NOTE: This file implements the JDBC 2 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 1 class in the -// postgresql.jdbc1 package. - -import java.sql.*; -import java.math.*; - -/** - * CallableStatement is used to execute SQL stored procedures. - * - *

JDBC provides a stored procedure SQL escape that allows stored - * procedures to be called in a standard way for all RDBMS's. This escape - * syntax has one form that includes a result parameter and one that does - * not. If used, the result parameter must be registered as an OUT - * parameter. The other parameters may be used for input, output or both. - * Parameters are refered to sequentially, by number. The first parameter - * is 1. - * - * {?= call [,, ...]} - * {call [,, ...]} - * - * - *

IN parameter values are set using the set methods inherited from - * PreparedStatement. The type of all OUT parameters must be registered - * prior to executing the stored procedure; their values are retrieved - * after execution via the get methods provided here. - * - *

A Callable statement may return a ResultSet or multiple ResultSets. - * Multiple ResultSets are handled using operations inherited from - * Statement. - * - *

For maximum portability, a call's ResultSets and update counts should - * be processed prior to getting the values of output parameters. - * - * @see Connection#prepareCall - * @see ResultSet - */ - -public class CallableStatement extends postgresql.jdbc2.PreparedStatement implements java.sql.CallableStatement -{ - /** - * @exception SQLException on failure - */ - public CallableStatement(Connection c,String q) throws SQLException - { - super(c,q); - } - - /** - * Before executing a stored procedure call you must explicitly - * call registerOutParameter to register the java.sql.Type of each - * out parameter. - * - *

Note: When reading the value of an out parameter, you must use - * the getXXX method whose Java type XXX corresponds to the - * parameter's registered SQL type. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @param sqlType SQL type code defined by java.sql.Types; for - * parameters of type Numeric or Decimal use the version of - * registerOutParameter that accepts a scale value - * @exception SQLException if a database-access error occurs. - */ - public void registerOutParameter(int parameterIndex, int sqlType) throws SQLException { - } - - /** - * You must also specify the scale for numeric/decimal types: - * - *

Note: When reading the value of an out parameter, you must use - * the getXXX method whose Java type XXX corresponds to the - * parameter's registered SQL type. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @param sqlType use either java.sql.Type.NUMERIC or java.sql.Type.DECIMAL - * @param scale a value greater than or equal to zero representing the - * desired number of digits to the right of the decimal point - * @exception SQLException if a database-access error occurs. - */ - public void registerOutParameter(int parameterIndex, int sqlType, - int scale) throws SQLException - { - } - - // Old api? - //public boolean isNull(int parameterIndex) throws SQLException { - //return true; - //} - - /** - * An OUT parameter may have the value of SQL NULL; wasNull - * reports whether the last value read has this special value. - * - *

Note: You must first call getXXX on a parameter to read its - * value and then call wasNull() to see if the value was SQL NULL. - * @return true if the last parameter read was SQL NULL - * @exception SQLException if a database-access error occurs. - */ - public boolean wasNull() throws SQLException { - // check to see if the last access threw an exception - return false; // fake it for now - } - - // Old api? - //public String getChar(int parameterIndex) throws SQLException { - //return null; - //} - - /** - * Get the value of a CHAR, VARCHAR, or LONGVARCHAR parameter as a - * Java String. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public String getString(int parameterIndex) throws SQLException { - return null; - } - //public String getVarChar(int parameterIndex) throws SQLException { - // return null; - //} - - //public String getLongVarChar(int parameterIndex) throws SQLException { - //return null; - //} - - /** - * Get the value of a BIT parameter as a Java boolean. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is false - * @exception SQLException if a database-access error occurs. - */ - public boolean getBoolean(int parameterIndex) throws SQLException { - return false; - } - - /** - * Get the value of a TINYINT parameter as a Java byte. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public byte getByte(int parameterIndex) throws SQLException { - return 0; - } - - /** - * Get the value of a SMALLINT parameter as a Java short. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public short getShort(int parameterIndex) throws SQLException { - return 0; - } - - /** - * Get the value of an INTEGER parameter as a Java int. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ -public int getInt(int parameterIndex) throws SQLException { - return 0; - } - - /** - * Get the value of a BIGINT parameter as a Java long. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public long getLong(int parameterIndex) throws SQLException { - return 0; - } - - /** - * Get the value of a FLOAT parameter as a Java float. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public float getFloat(int parameterIndex) throws SQLException { - return (float) 0.0; - } - - /** - * Get the value of a DOUBLE parameter as a Java double. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is 0 - * @exception SQLException if a database-access error occurs. - */ - public double getDouble(int parameterIndex) throws SQLException { - return 0.0; - } - - /** - * Get the value of a NUMERIC parameter as a java.math.BigDecimal - * object. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @param scale a value greater than or equal to zero representing the - * desired number of digits to the right of the decimal point - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public BigDecimal getBigDecimal(int parameterIndex, int scale) - throws SQLException { - return null; - } - - /** - * Get the value of a SQL BINARY or VARBINARY parameter as a Java - * byte[] - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public byte[] getBytes(int parameterIndex) throws SQLException { - return null; - } - - // New API (JPM) (getLongVarBinary) - //public byte[] getBinaryStream(int parameterIndex) throws SQLException { - //return null; - //} - - /** - * Get the value of a SQL DATE parameter as a java.sql.Date object - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public java.sql.Date getDate(int parameterIndex) throws SQLException { - return null; - } - - /** - * Get the value of a SQL TIME parameter as a java.sql.Time object. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public java.sql.Time getTime(int parameterIndex) throws SQLException { - return null; - } - - /** - * Get the value of a SQL TIMESTAMP parameter as a java.sql.Timestamp object. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return the parameter value; if the value is SQL NULL, the result is null - * @exception SQLException if a database-access error occurs. - */ - public java.sql.Timestamp getTimestamp(int parameterIndex) - throws SQLException { - return null; - } - - //---------------------------------------------------------------------- - // Advanced features: - - // You can obtain a ParameterMetaData object to get information - // about the parameters to this CallableStatement. - //public DatabaseMetaData getMetaData() { - //return null; - //} - - // getObject returns a Java object for the parameter. - // See the JDBC spec's "Dynamic Programming" chapter for details. - /** - * Get the value of a parameter as a Java object. - * - *

This method returns a Java object whose type coresponds to the - * SQL type that was registered for this parameter using - * registerOutParameter. - * - *

Note that this method may be used to read datatabase-specific, - * abstract data types. This is done by specifying a targetSqlType - * of java.sql.types.OTHER, which allows the driver to return a - * database-specific Java type. - * - *

See the JDBC spec's "Dynamic Programming" chapter for details. - * - * @param parameterIndex the first parameter is 1, the second is 2,... - * @return A java.lang.Object holding the OUT parameter value. - * @exception SQLException if a database-access error occurs. - */ - public Object getObject(int parameterIndex) - throws SQLException { - return null; - } - - // ** JDBC 2 Extensions ** - - public Array getArray(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.math.BigDecimal getBigDecimal(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Blob getBlob(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Clob getClob(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Object getObject(int i,java.util.Map map) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Ref getRef(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.sql.Date getDate(int i,java.util.Calendar cal) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Time getTime(int i,java.util.Calendar cal) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Timestamp getTimestamp(int i,java.util.Calendar cal) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void registerOutParameter(int parameterIndex, int sqlType,String typeName) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - -} - diff --git a/src/interfaces/jdbc/postgresql/jdbc2/Connection.java b/src/interfaces/jdbc/postgresql/jdbc2/Connection.java deleted file mode 100644 index 32ffce81ee..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc2/Connection.java +++ /dev/null @@ -1,441 +0,0 @@ -package postgresql.jdbc2; - -// IMPORTANT NOTE: This file implements the JDBC 2 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 1 class in the -// postgresql.jdbc1 package. - -import java.io.*; -import java.lang.*; -import java.lang.reflect.*; -import java.net.*; -import java.util.*; -import java.sql.*; -import postgresql.Field; -import postgresql.fastpath.*; -import postgresql.largeobject.*; -import postgresql.util.*; - -/** - * $Id: Connection.java,v 1.3 1999/09/14 05:50:44 peter Exp $ - * - * A Connection represents a session with a specific database. Within the - * context of a Connection, SQL statements are executed and results are - * returned. - * - *

A Connection's database is able to provide information describing - * its tables, its supported SQL grammar, its stored procedures, the - * capabilities of this connection, etc. This information is obtained - * with the getMetaData method. - * - *

Note: By default, the Connection automatically commits changes - * after executing each statement. If auto-commit has been disabled, an - * explicit commit must be done or database changes will not be saved. - * - * @see java.sql.Connection - */ -public class Connection extends postgresql.Connection implements java.sql.Connection -{ - // This is a cache of the DatabaseMetaData instance for this connection - protected DatabaseMetaData metadata; - - /** - * SQL statements without parameters are normally executed using - * Statement objects. If the same SQL statement is executed many - * times, it is more efficient to use a PreparedStatement - * - * @return a new Statement object - * @exception SQLException passed through from the constructor - */ - public java.sql.Statement createStatement() throws SQLException - { - return new Statement(this); - } - - /** - * A SQL statement with or without IN parameters can be pre-compiled - * and stored in a PreparedStatement object. This object can then - * be used to efficiently execute this statement multiple times. - * - * Note: This method is optimized for handling parametric - * SQL statements that benefit from precompilation if the drivers - * supports precompilation. PostgreSQL does not support precompilation. - * In this case, the statement is not sent to the database until the - * PreparedStatement is executed. This has no direct effect on users; - * however it does affect which method throws certain SQLExceptions - * - * @param sql a SQL statement that may contain one or more '?' IN - * parameter placeholders - * @return a new PreparedStatement object containing the pre-compiled - * statement. - * @exception SQLException if a database access error occurs. - */ - public java.sql.PreparedStatement prepareStatement(String sql) throws SQLException - { - return new PreparedStatement(this, sql); - } - - /** - * A SQL stored procedure call statement is handled by creating a - * CallableStatement for it. The CallableStatement provides methods - * for setting up its IN and OUT parameters and methods for executing - * it. - * - * Note: This method is optimised for handling stored procedure - * call statements. Some drivers may send the call statement to the - * database when the prepareCall is done; others may wait until the - * CallableStatement is executed. This has no direct effect on users; - * however, it does affect which method throws certain SQLExceptions - * - * @param sql a SQL statement that may contain one or more '?' parameter - * placeholders. Typically this statement is a JDBC function call - * escape string. - * @return a new CallableStatement object containing the pre-compiled - * SQL statement - * @exception SQLException if a database access error occurs - */ - public java.sql.CallableStatement prepareCall(String sql) throws SQLException - { - throw new PSQLException("postgresql.con.call"); - // return new CallableStatement(this, sql); - } - - /** - * A driver may convert the JDBC sql grammar into its system's - * native SQL grammar prior to sending it; nativeSQL returns the - * native form of the statement that the driver would have sent. - * - * @param sql a SQL statement that may contain one or more '?' - * parameter placeholders - * @return the native form of this statement - * @exception SQLException if a database access error occurs - */ - public String nativeSQL(String sql) throws SQLException - { - return sql; - } - - /** - * If a connection is in auto-commit mode, than all its SQL - * statements will be executed and committed as individual - * transactions. Otherwise, its SQL statements are grouped - * into transactions that are terminated by either commit() - * or rollback(). By default, new connections are in auto- - * commit mode. The commit occurs when the statement completes - * or the next execute occurs, whichever comes first. In the - * case of statements returning a ResultSet, the statement - * completes when the last row of the ResultSet has been retrieved - * or the ResultSet has been closed. In advanced cases, a single - * statement may return multiple results as well as output parameter - * values. Here the commit occurs when all results and output param - * values have been retrieved. - * - * @param autoCommit - true enables auto-commit; false disables it - * @exception SQLException if a database access error occurs - */ - public void setAutoCommit(boolean autoCommit) throws SQLException - { - if (this.autoCommit == autoCommit) - return; - if (autoCommit) - ExecSQL("end"); - else - ExecSQL("begin"); - this.autoCommit = autoCommit; - } - - /** - * gets the current auto-commit state - * - * @return Current state of the auto-commit mode - * @exception SQLException (why?) - * @see setAutoCommit - */ - public boolean getAutoCommit() throws SQLException - { - return this.autoCommit; - } - - /** - * The method commit() makes all changes made since the previous - * commit/rollback permanent and releases any database locks currently - * held by the Connection. This method should only be used when - * auto-commit has been disabled. (If autoCommit == true, then we - * just return anyhow) - * - * @exception SQLException if a database access error occurs - * @see setAutoCommit - */ - public void commit() throws SQLException - { - if (autoCommit) - return; - ExecSQL("commit"); - autoCommit = true; - ExecSQL("begin"); - autoCommit = false; - } - - /** - * The method rollback() drops all changes made since the previous - * commit/rollback and releases any database locks currently held by - * the Connection. - * - * @exception SQLException if a database access error occurs - * @see commit - */ - public void rollback() throws SQLException - { - if (autoCommit) - return; - ExecSQL("rollback"); - autoCommit = true; - ExecSQL("begin"); - autoCommit = false; - } - - /** - * In some cases, it is desirable to immediately release a Connection's - * database and JDBC resources instead of waiting for them to be - * automatically released (cant think why off the top of my head) - * - * Note: A Connection is automatically closed when it is - * garbage collected. Certain fatal errors also result in a closed - * connection. - * - * @exception SQLException if a database access error occurs - */ - public void close() throws SQLException - { - if (pg_stream != null) - { - try - { - pg_stream.close(); - } catch (IOException e) {} - pg_stream = null; - } - } - - /** - * Tests to see if a Connection is closed - * - * @return the status of the connection - * @exception SQLException (why?) - */ - public boolean isClosed() throws SQLException - { - return (pg_stream == null); - } - - /** - * A connection's database is able to provide information describing - * its tables, its supported SQL grammar, its stored procedures, the - * capabilities of this connection, etc. This information is made - * available through a DatabaseMetaData object. - * - * @return a DatabaseMetaData object for this connection - * @exception SQLException if a database access error occurs - */ - public java.sql.DatabaseMetaData getMetaData() throws SQLException - { - if(metadata==null) - metadata = new DatabaseMetaData(this); - return metadata; - } - - /** - * You can put a connection in read-only mode as a hunt to enable - * database optimizations - * - * Note: setReadOnly cannot be called while in the middle - * of a transaction - * - * @param readOnly - true enables read-only mode; false disables it - * @exception SQLException if a database access error occurs - */ - public void setReadOnly (boolean readOnly) throws SQLException - { - this.readOnly = readOnly; - } - - /** - * Tests to see if the connection is in Read Only Mode. Note that - * we cannot really put the database in read only mode, but we pretend - * we can by returning the value of the readOnly flag - * - * @return true if the connection is read only - * @exception SQLException if a database access error occurs - */ - public boolean isReadOnly() throws SQLException - { - return readOnly; - } - - /** - * A sub-space of this Connection's database may be selected by - * setting a catalog name. If the driver does not support catalogs, - * it will silently ignore this request - * - * @exception SQLException if a database access error occurs - */ - public void setCatalog(String catalog) throws SQLException - { - // No-op - } - - /** - * Return the connections current catalog name, or null if no - * catalog name is set, or we dont support catalogs. - * - * @return the current catalog name or null - * @exception SQLException if a database access error occurs - */ - public String getCatalog() throws SQLException - { - return null; - } - - /** - * You can call this method to try to change the transaction - * isolation level using one of the TRANSACTION_* values. - * - * Note: setTransactionIsolation cannot be called while - * in the middle of a transaction - * - * @param level one of the TRANSACTION_* isolation values with - * the exception of TRANSACTION_NONE; some databases may - * not support other values - * @exception SQLException if a database access error occurs - * @see java.sql.DatabaseMetaData#supportsTransactionIsolationLevel - */ - public void setTransactionIsolation(int level) throws SQLException - { - String q = "SET TRANSACTION ISOLATION LEVEL"; - - switch(level) { - - case java.sql.Connection.TRANSACTION_READ_COMMITTED: - ExecSQL(q + " READ COMMITTED"); - return; - - case java.sql.Connection.TRANSACTION_SERIALIZABLE: - ExecSQL(q + " SERIALIZABLE"); - return; - - default: - throw new PSQLException("postgresql.con.isolevel",new Integer(level)); - } - } - - /** - * Get this Connection's current transaction isolation mode. - * - * @return the current TRANSACTION_* mode value - * @exception SQLException if a database access error occurs - */ - public int getTransactionIsolation() throws SQLException - { - ExecSQL("show xactisolevel"); - - SQLWarning w = getWarnings(); - if (w != null) { - if (w.getMessage().indexOf("READ COMMITTED") != -1) return java.sql.Connection.TRANSACTION_READ_COMMITTED; else - if (w.getMessage().indexOf("READ UNCOMMITTED") != -1) return java.sql.Connection.TRANSACTION_READ_UNCOMMITTED; else - if (w.getMessage().indexOf("REPEATABLE READ") != -1) return java.sql.Connection.TRANSACTION_REPEATABLE_READ; else - if (w.getMessage().indexOf("SERIALIZABLE") != -1) return java.sql.Connection.TRANSACTION_SERIALIZABLE; - } - return java.sql.Connection.TRANSACTION_READ_COMMITTED; - } - - /** - * The first warning reported by calls on this Connection is - * returned. - * - * Note: Sebsequent warnings will be changed to this - * SQLWarning - * - * @return the first SQLWarning or null - * @exception SQLException if a database access error occurs - */ - public SQLWarning getWarnings() throws SQLException - { - return firstWarning; - } - - /** - * After this call, getWarnings returns null until a new warning - * is reported for this connection. - * - * @exception SQLException if a database access error occurs - */ - public void clearWarnings() throws SQLException - { - firstWarning = null; - } - - /** - * This overides the method in postgresql.Connection and returns a - * ResultSet. - */ - protected java.sql.ResultSet getResultSet(postgresql.Connection conn, Field[] fields, Vector tuples, String status, int updateCount) throws SQLException - { - return new postgresql.jdbc2.ResultSet((postgresql.jdbc2.Connection)conn,fields,tuples,status,updateCount); - } - - // ***************** - // JDBC 2 extensions - // ***************** - - public java.sql.Statement createStatement(int resultSetType,int resultSetConcurrency) throws SQLException - { - // normal create followed by 2 sets? - throw postgresql.Driver.notImplemented(); - } - - public java.sql.PreparedStatement prepareStatement(String sql,int resultSetType,int resultSetConcurrency) throws SQLException - { - // normal prepare followed by 2 sets? - throw postgresql.Driver.notImplemented(); - } - - public java.sql.CallableStatement prepareCall(String sql,int resultSetType,int resultSetConcurrency) throws SQLException - { - // normal prepare followed by 2 sets? - throw postgresql.Driver.notImplemented(); - } - - public int getResultSetConcurrency() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public int getResultSetType() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.util.Map getTypeMap() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setResultSetConcurrency(int value) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setResultSetType(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setTypeMap(java.util.Map map) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - -} - -// *********************************************************************** - diff --git a/src/interfaces/jdbc/postgresql/jdbc2/DatabaseMetaData.java b/src/interfaces/jdbc/postgresql/jdbc2/DatabaseMetaData.java deleted file mode 100644 index a936cb518c..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc2/DatabaseMetaData.java +++ /dev/null @@ -1,2621 +0,0 @@ -package postgresql.jdbc2; - -// IMPORTANT NOTE: This file implements the JDBC 2 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 1 class in the -// postgresql.jdbc1 package. - -import java.sql.*; -import java.util.*; -import postgresql.Field; - -/** - * This class provides information about the database as a whole. - * - *

Many of the methods here return lists of information in ResultSets. You - * can use the normal ResultSet methods such as getString and getInt to - * retrieve the data from these ResultSets. If a given form of metadata is - * not available, these methods should throw a SQLException. - * - *

Some of these methods take arguments that are String patterns. These - * arguments all have names such as fooPattern. Within a pattern String, - * "%" means match any substring of 0 or more characters, and "_" means - * match any one character. Only metadata entries matching the search - * pattern are returned. if a search pattern argument is set to a null - * ref, it means that argument's criteria should be dropped from the - * search. - * - *

A SQLException will be throws if a driver does not support a meta - * data method. In the case of methods that return a ResultSet, either - * a ResultSet (which may be empty) is returned or a SQLException is - * thrown. - * - * @see java.sql.DatabaseMetaData - */ -public class DatabaseMetaData implements java.sql.DatabaseMetaData -{ - Connection connection; // The connection association - - // These define various OID's. Hopefully they will stay constant. - static final int iVarcharOid = 1043; // OID for varchar - static final int iBoolOid = 16; // OID for bool - static final int iInt2Oid = 21; // OID for int2 - static final int iInt4Oid = 23; // OID for int4 - static final int VARHDRSZ = 4; // length for int4 - - // This is a default value for remarks - private static final byte defaultRemarks[]="no remarks".getBytes(); - - public DatabaseMetaData(Connection conn) - { - this.connection = conn; - } - - /** - * Can all the procedures returned by getProcedures be called - * by the current user? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean allProceduresAreCallable() throws SQLException - { - return true; // For now... - } - - /** - * Can all the tables returned by getTable be SELECTed by - * the current user? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean allTablesAreSelectable() throws SQLException - { - return true; // For now... - } - - /** - * What is the URL for this database? - * - * @return the url or null if it cannott be generated - * @exception SQLException if a database access error occurs - */ - public String getURL() throws SQLException - { - return connection.getURL(); - } - - /** - * What is our user name as known to the database? - * - * @return our database user name - * @exception SQLException if a database access error occurs - */ - public String getUserName() throws SQLException - { - return connection.getUserName(); - } - - /** - * Is the database in read-only mode? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isReadOnly() throws SQLException - { - return connection.isReadOnly(); - } - - /** - * Are NULL values sorted high? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullsAreSortedHigh() throws SQLException - { - return false; - } - - /** - * Are NULL values sorted low? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullsAreSortedLow() throws SQLException - { - return false; - } - - /** - * Are NULL values sorted at the start regardless of sort order? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullsAreSortedAtStart() throws SQLException - { - return false; - } - - /** - * Are NULL values sorted at the end regardless of sort order? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullsAreSortedAtEnd() throws SQLException - { - return true; - } - - /** - * What is the name of this database product - we hope that it is - * PostgreSQL, so we return that explicitly. - * - * @return the database product name - * @exception SQLException if a database access error occurs - */ - public String getDatabaseProductName() throws SQLException - { - return new String("PostgreSQL"); - } - - /** - * What is the version of this database product. - * - *

Note that PostgreSQL 6.3 has a system catalog called pg_version - - * however, select * from pg_version on any database retrieves - * no rows. - * - *

For now, we will return the version 6.3 (in the hope that we change - * this driver as often as we change the database) - * - * @return the database version - * @exception SQLException if a database access error occurs - */ - public String getDatabaseProductVersion() throws SQLException - { - return ("7.1"); - } - - /** - * What is the name of this JDBC driver? If we don't know this - * we are doing something wrong! - * - * @return the JDBC driver name - * @exception SQLException why? - */ - public String getDriverName() throws SQLException - { - return new String("PostgreSQL Native Driver"); - } - - /** - * What is the version string of this JDBC driver? Again, this is - * static. - * - * @return the JDBC driver name. - * @exception SQLException why? - */ - public String getDriverVersion() throws SQLException - { - return new String(Integer.toString(connection.this_driver.getMajorVersion())+"."+Integer.toString(connection.this_driver.getMinorVersion())); - } - - /** - * What is this JDBC driver's major version number? - * - * @return the JDBC driver major version - */ - public int getDriverMajorVersion() - { - return connection.this_driver.getMajorVersion(); - } - - /** - * What is this JDBC driver's minor version number? - * - * @return the JDBC driver minor version - */ - public int getDriverMinorVersion() - { - return connection.this_driver.getMinorVersion(); - } - - /** - * Does the database store tables in a local file? No - it - * stores them in a file on the server. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean usesLocalFiles() throws SQLException - { - return false; - } - - /** - * Does the database use a file for each table? Well, not really, - * since it doesnt use local files. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean usesLocalFilePerTable() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case unquoted SQL identifiers - * as case sensitive and as a result store them in mixed case? - * A JDBC-Compliant driver will always return false. - * - *

Predicament - what do they mean by "SQL identifiers" - if it - * means the names of the tables and columns, then the answers - * given below are correct - otherwise I don't know. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMixedCaseIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case unquoted SQL identifiers as - * case insensitive and store them in upper case? - * - * @return true if so - */ - public boolean storesUpperCaseIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case unquoted SQL identifiers as - * case insensitive and store them in lower case? - * - * @return true if so - */ - public boolean storesLowerCaseIdentifiers() throws SQLException - { - return true; - } - - /** - * Does the database treat mixed case unquoted SQL identifiers as - * case insensitive and store them in mixed case? - * - * @return true if so - */ - public boolean storesMixedCaseIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case quoted SQL identifiers as - * case sensitive and as a result store them in mixed case? A - * JDBC compliant driver will always return true. - * - *

Predicament - what do they mean by "SQL identifiers" - if it - * means the names of the tables and columns, then the answers - * given below are correct - otherwise I don't know. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException - { - return true; - } - - /** - * Does the database treat mixed case quoted SQL identifiers as - * case insensitive and store them in upper case? - * - * @return true if so - */ - public boolean storesUpperCaseQuotedIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case quoted SQL identifiers as case - * insensitive and store them in lower case? - * - * @return true if so - */ - public boolean storesLowerCaseQuotedIdentifiers() throws SQLException - { - return false; - } - - /** - * Does the database treat mixed case quoted SQL identifiers as case - * insensitive and store them in mixed case? - * - * @return true if so - */ - public boolean storesMixedCaseQuotedIdentifiers() throws SQLException - { - return false; - } - - /** - * What is the string used to quote SQL identifiers? This returns - * a space if identifier quoting isn't supported. A JDBC Compliant - * driver will always use a double quote character. - * - *

If an SQL identifier is a table name, column name, etc. then - * we do not support it. - * - * @return the quoting string - * @exception SQLException if a database access error occurs - */ - public String getIdentifierQuoteString() throws SQLException - { - return null; - } - - /** - * Get a comma separated list of all a database's SQL keywords that - * are NOT also SQL92 keywords. - * - *

Within PostgreSQL, the keywords are found in - * src/backend/parser/keywords.c - * - *

For SQL Keywords, I took the list provided at - * - * http://web.dementia.org/~shadow/sql/sql3bnf.sep93.txt - * which is for SQL3, not SQL-92, but it is close enough for - * this purpose. - * - * @return a comma separated list of keywords we use - * @exception SQLException if a database access error occurs - */ - public String getSQLKeywords() throws SQLException - { - return new String("abort,acl,add,aggregate,append,archive,arch_store,backward,binary,change,cluster,copy,database,delimiters,do,extend,explain,forward,heavy,index,inherits,isnull,light,listen,load,merge,nothing,notify,notnull,oids,purge,rename,replace,retrieve,returns,rule,recipe,setof,stdin,stdout,store,vacuum,verbose,version"); - } - - public String getNumericFunctions() throws SQLException - { - // XXX-Not Implemented - return ""; - } - - public String getStringFunctions() throws SQLException - { - // XXX-Not Implemented - return ""; - } - - public String getSystemFunctions() throws SQLException - { - // XXX-Not Implemented - return ""; - } - - public String getTimeDateFunctions() throws SQLException - { - // XXX-Not Implemented - return ""; - } - - /** - * This is the string that can be used to escape '_' and '%' in - * a search string pattern style catalog search parameters - * - * @return the string used to escape wildcard characters - * @exception SQLException if a database access error occurs - */ - public String getSearchStringEscape() throws SQLException - { - return new String("\\"); - } - - /** - * Get all the "extra" characters that can bew used in unquoted - * identifier names (those beyond a-zA-Z0-9 and _) - * - *

From the file src/backend/parser/scan.l, an identifier is - * {letter}{letter_or_digit} which makes it just those listed - * above. - * - * @return a string containing the extra characters - * @exception SQLException if a database access error occurs - */ - public String getExtraNameCharacters() throws SQLException - { - return new String(""); - } - - /** - * Is "ALTER TABLE" with an add column supported? - * Yes for PostgreSQL 6.1 - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsAlterTableWithAddColumn() throws SQLException - { - return true; - } - - /** - * Is "ALTER TABLE" with a drop column supported? - * Yes for PostgreSQL 6.1 - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsAlterTableWithDropColumn() throws SQLException - { - return true; - } - - /** - * Is column aliasing supported? - * - *

If so, the SQL AS clause can be used to provide names for - * computed columns or to provide alias names for columns as - * required. A JDBC Compliant driver always returns true. - * - *

e.g. - * - * 

-   * select count(C) as C_COUNT from T group by C;
-   *
-   *

- * should return a column named as C_COUNT instead of count(C) - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsColumnAliasing() throws SQLException - { - return true; - } - - /** - * Are concatenations between NULL and non-NULL values NULL? A - * JDBC Compliant driver always returns true - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean nullPlusNonNullIsNull() throws SQLException - { - return true; - } - - public boolean supportsConvert() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsConvert(int fromType, int toType) throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsTableCorrelationNames() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsDifferentTableCorrelationNames() throws SQLException - { - // XXX-Not Implemented - return false; - } - - /** - * Are expressions in "ORCER BY" lists supported? - * - *
e.g. select * from t order by a + b; - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsExpressionsInOrderBy() throws SQLException - { - return true; - } - - /** - * Can an "ORDER BY" clause use columns not in the SELECT? - * I checked it, and you can't. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsOrderByUnrelated() throws SQLException - { - return false; - } - - /** - * Is some form of "GROUP BY" clause supported? - * I checked it, and yes it is. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsGroupBy() throws SQLException - { - return true; - } - - /** - * Can a "GROUP BY" clause use columns not in the SELECT? - * I checked it - it seems to allow it - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsGroupByUnrelated() throws SQLException - { - return true; - } - - /** - * Can a "GROUP BY" clause add columns not in the SELECT provided - * it specifies all the columns in the SELECT? Does anyone actually - * understand what they mean here? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsGroupByBeyondSelect() throws SQLException - { - return true; // For now... - } - - /** - * Is the escape character in "LIKE" clauses supported? A - * JDBC compliant driver always returns true. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsLikeEscapeClause() throws SQLException - { - return true; - } - - /** - * Are multiple ResultSets from a single execute supported? - * Well, I implemented it, but I dont think this is possible from - * the back ends point of view. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMultipleResultSets() throws SQLException - { - return false; - } - - /** - * Can we have multiple transactions open at once (on different - * connections?) - * I guess we can have, since Im relying on it. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMultipleTransactions() throws SQLException - { - return true; - } - - /** - * Can columns be defined as non-nullable. A JDBC Compliant driver - * always returns true. - * - *

This changed from false to true in v6.2 of the driver, as this - * support was added to the backend. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsNonNullableColumns() throws SQLException - { - return true; - } - - /** - * Does this driver support the minimum ODBC SQL grammar. This - * grammar is defined at: - * - *

http://www.microsoft.com/msdn/sdk/platforms/doc/odbc/src/intropr.htm - * - *

In Appendix C. From this description, we seem to support the - * ODBC minimal (Level 0) grammar. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsMinimumSQLGrammar() throws SQLException - { - return true; - } - - /** - * Does this driver support the Core ODBC SQL grammar. We need - * SQL-92 conformance for this. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCoreSQLGrammar() throws SQLException - { - return false; - } - - /** - * Does this driver support the Extended (Level 2) ODBC SQL - * grammar. We don't conform to the Core (Level 1), so we can't - * conform to the Extended SQL Grammar. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsExtendedSQLGrammar() throws SQLException - { - return false; - } - - /** - * Does this driver support the ANSI-92 entry level SQL grammar? - * All JDBC Compliant drivers must return true. I think we have - * to support outer joins for this to be true. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsANSI92EntryLevelSQL() throws SQLException - { - return false; - } - - /** - * Does this driver support the ANSI-92 intermediate level SQL - * grammar? Anyone who does not support Entry level cannot support - * Intermediate level. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsANSI92IntermediateSQL() throws SQLException - { - return false; - } - - /** - * Does this driver support the ANSI-92 full SQL grammar? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsANSI92FullSQL() throws SQLException - { - return false; - } - - /** - * Is the SQL Integrity Enhancement Facility supported? - * I haven't seen this mentioned anywhere, so I guess not - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsIntegrityEnhancementFacility() throws SQLException - { - return false; - } - - /** - * Is some form of outer join supported? From my knowledge, nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsOuterJoins() throws SQLException - { - return false; - } - - /** - * Are full nexted outer joins supported? Well, we dont support any - * form of outer join, so this is no as well - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsFullOuterJoins() throws SQLException - { - return false; - } - - /** - * Is there limited support for outer joins? (This will be true if - * supportFullOuterJoins is true) - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsLimitedOuterJoins() throws SQLException - { - return false; - } - - /** - * What is the database vendor's preferred term for "schema" - well, - * we do not provide support for schemas, so lets just use that - * term. - * - * @return the vendor term - * @exception SQLException if a database access error occurs - */ - public String getSchemaTerm() throws SQLException - { - return new String("Schema"); - } - - /** - * What is the database vendor's preferred term for "procedure" - - * I kind of like "Procedure" myself. - * - * @return the vendor term - * @exception SQLException if a database access error occurs - */ - public String getProcedureTerm() throws SQLException - { - return new String("Procedure"); - } - - /** - * What is the database vendor's preferred term for "catalog"? - - * we dont have a preferred term, so just use Catalog - * - * @return the vendor term - * @exception SQLException if a database access error occurs - */ - public String getCatalogTerm() throws SQLException - { - return new String("Catalog"); - } - - /** - * Does a catalog appear at the start of a qualified table name? - * (Otherwise it appears at the end). - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isCatalogAtStart() throws SQLException - { - return false; - } - - /** - * What is the Catalog separator. Hmmm....well, I kind of like - * a period (so we get catalog.table definitions). - I don't think - * PostgreSQL supports catalogs anyhow, so it makes no difference. - * - * @return the catalog separator string - * @exception SQLException if a database access error occurs - */ - public String getCatalogSeparator() throws SQLException - { - // PM Sep 29 97 - changed from "." as we don't support catalogs. - return new String(""); - } - - /** - * Can a schema name be used in a data manipulation statement? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInDataManipulation() throws SQLException - { - return false; - } - - /** - * Can a schema name be used in a procedure call statement? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInProcedureCalls() throws SQLException - { - return false; - } - - /** - * Can a schema be used in a table definition statement? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInTableDefinitions() throws SQLException - { - return false; - } - - /** - * Can a schema name be used in an index definition statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInIndexDefinitions() throws SQLException - { - return false; - } - - /** - * Can a schema name be used in a privilege definition statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in a data manipulation statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInDataManipulation() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in a procedure call statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInProcedureCalls() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in a table definition statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInTableDefinitions() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in an index definition? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInIndexDefinitions() throws SQLException - { - return false; - } - - /** - * Can a catalog name be used in a privilege definition statement? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException - { - return false; - } - - /** - * We support cursors for gets only it seems. I dont see a method - * to get a positioned delete. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsPositionedDelete() throws SQLException - { - return false; // For now... - } - - /** - * Is positioned UPDATE supported? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsPositionedUpdate() throws SQLException - { - return false; // For now... - } - - public boolean supportsSelectForUpdate() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsStoredProcedures() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsSubqueriesInComparisons() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsSubqueriesInExists() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsSubqueriesInIns() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsSubqueriesInQuantifieds() throws SQLException - { - // XXX-Not Implemented - return false; - } - - public boolean supportsCorrelatedSubqueries() throws SQLException - { - // XXX-Not Implemented - return false; - } - - /** - * Is SQL UNION supported? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsUnion() throws SQLException - { - return false; - } - - /** - * Is SQL UNION ALL supported? Nope. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsUnionAll() throws SQLException - { - return false; - } - - /** - * In PostgreSQL, Cursors are only open within transactions. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsOpenCursorsAcrossCommit() throws SQLException - { - return false; - } - - /** - * Do we support open cursors across multiple transactions? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsOpenCursorsAcrossRollback() throws SQLException - { - return false; - } - - /** - * Can statements remain open across commits? They may, but - * this driver cannot guarentee that. In further reflection. - * we are talking a Statement object jere, so the answer is - * yes, since the Statement is only a vehicle to ExecSQL() - * - * @return true if they always remain open; false otherwise - * @exception SQLException if a database access error occurs - */ - public boolean supportsOpenStatementsAcrossCommit() throws SQLException - { - return true; - } - - /** - * Can statements remain open across rollbacks? They may, but - * this driver cannot guarentee that. In further contemplation, - * we are talking a Statement object here, so the answer is yes, - * since the Statement is only a vehicle to ExecSQL() in Connection - * - * @return true if they always remain open; false otherwise - * @exception SQLException if a database access error occurs - */ - public boolean supportsOpenStatementsAcrossRollback() throws SQLException - { - return true; - } - - /** - * How many hex characters can you have in an inline binary literal - * - * @return the max literal length - * @exception SQLException if a database access error occurs - */ - public int getMaxBinaryLiteralLength() throws SQLException - { - return 0; // For now... - } - - /** - * What is the maximum length for a character literal - * I suppose it is 8190 (8192 - 2 for the quotes) - * - * @return the max literal length - * @exception SQLException if a database access error occurs - */ - public int getMaxCharLiteralLength() throws SQLException - { - return 8190; - } - - /** - * Whats the limit on column name length. The description of - * pg_class would say '32' (length of pg_class.relname) - we - * should probably do a query for this....but.... - * - * @return the maximum column name length - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnNameLength() throws SQLException - { - return 32; - } - - /** - * What is the maximum number of columns in a "GROUP BY" clause? - * - * @return the max number of columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInGroupBy() throws SQLException - { - return getMaxColumnsInTable(); - } - - /** - * What's the maximum number of columns allowed in an index? - * 6.0 only allowed one column, but 6.1 introduced multi-column - * indices, so, theoretically, its all of them. - * - * @return max number of columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInIndex() throws SQLException - { - return getMaxColumnsInTable(); - } - - /** - * What's the maximum number of columns in an "ORDER BY clause? - * Theoretically, all of them! - * - * @return the max columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInOrderBy() throws SQLException - { - return getMaxColumnsInTable(); - } - - /** - * What is the maximum number of columns in a "SELECT" list? - * Theoretically, all of them! - * - * @return the max columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInSelect() throws SQLException - { - return getMaxColumnsInTable(); - } - - /** - * What is the maximum number of columns in a table? From the - * create_table(l) manual page... - * - *

"The new class is created as a heap with no initial data. A - * class can have no more than 1600 attributes (realistically, - * this is limited by the fact that tuple sizes must be less than - * 8192 bytes)..." - * - * @return the max columns - * @exception SQLException if a database access error occurs - */ - public int getMaxColumnsInTable() throws SQLException - { - return 1600; - } - - /** - * How many active connection can we have at a time to this - * database? Well, since it depends on postmaster, which just - * does a listen() followed by an accept() and fork(), its - * basically very high. Unless the system runs out of processes, - * it can be 65535 (the number of aux. ports on a TCP/IP system). - * I will return 8192 since that is what even the largest system - * can realistically handle, - * - * @return the maximum number of connections - * @exception SQLException if a database access error occurs - */ - public int getMaxConnections() throws SQLException - { - return 8192; - } - - /** - * What is the maximum cursor name length (the same as all - * the other F***** identifiers!) - * - * @return max cursor name length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxCursorNameLength() throws SQLException - { - return 32; - } - - /** - * What is the maximum length of an index (in bytes)? Now, does - * the spec. mean name of an index (in which case its 32, the - * same as a table) or does it mean length of an index element - * (in which case its 8192, the size of a row) or does it mean - * the number of rows it can access (in which case it 2^32 - - * a 4 byte OID number)? I think its the length of an index - * element, personally, so Im setting it to 8192. - * - * @return max index length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxIndexLength() throws SQLException - { - return 8192; - } - - public int getMaxSchemaNameLength() throws SQLException - { - // XXX-Not Implemented - return 0; - } - - /** - * What is the maximum length of a procedure name? - * (length of pg_proc.proname used) - again, I really - * should do a query here to get it. - * - * @return the max name length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxProcedureNameLength() throws SQLException - { - return 32; - } - - public int getMaxCatalogNameLength() throws SQLException - { - // XXX-Not Implemented - return 0; - } - - /** - * What is the maximum length of a single row? (not including - * blobs). 8192 is defined in PostgreSQL. - * - * @return max row size in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxRowSize() throws SQLException - { - return 8192; - } - - /** - * Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY - * blobs? We don't handle blobs yet - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean doesMaxRowSizeIncludeBlobs() throws SQLException - { - return false; - } - - /** - * What is the maximum length of a SQL statement? - * - * @return max length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxStatementLength() throws SQLException - { - return 8192; - } - - /** - * How many active statements can we have open at one time to - * this database? Basically, since each Statement downloads - * the results as the query is executed, we can have many. However, - * we can only really have one statement per connection going - * at once (since they are executed serially) - so we return - * one. - * - * @return the maximum - * @exception SQLException if a database access error occurs - */ - public int getMaxStatements() throws SQLException - { - return 1; - } - - /** - * What is the maximum length of a table name? This was found - * from pg_class.relname length - * - * @return max name length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxTableNameLength() throws SQLException - { - return 32; - } - - /** - * What is the maximum number of tables that can be specified - * in a SELECT? Theoretically, this is the same number as the - * number of tables allowable. In practice tho, it is much smaller - * since the number of tables is limited by the statement, we - * return 1024 here - this is just a number I came up with (being - * the number of tables roughly of three characters each that you - * can fit inside a 8192 character buffer with comma separators). - * - * @return the maximum - * @exception SQLException if a database access error occurs - */ - public int getMaxTablesInSelect() throws SQLException - { - return 1024; - } - - /** - * What is the maximum length of a user name? Well, we generally - * use UNIX like user names in PostgreSQL, so I think this would - * be 8. However, showing the schema for pg_user shows a length - * for username of 32. - * - * @return the max name length in bytes - * @exception SQLException if a database access error occurs - */ - public int getMaxUserNameLength() throws SQLException - { - return 32; - } - - - /** - * What is the database's default transaction isolation level? We - * do not support this, so all transactions are SERIALIZABLE. - * - * @return the default isolation level - * @exception SQLException if a database access error occurs - * @see Connection - */ - public int getDefaultTransactionIsolation() throws SQLException - { - return Connection.TRANSACTION_READ_COMMITTED; - } - - /** - * Are transactions supported? If not, commit and rollback are noops - * and the isolation level is TRANSACTION_NONE. We do support - * transactions. - * - * @return true if transactions are supported - * @exception SQLException if a database access error occurs - */ - public boolean supportsTransactions() throws SQLException - { - return true; - } - - /** - * Does the database support the given transaction isolation level? - * We only support TRANSACTION_SERIALIZABLE and TRANSACTION_READ_COMMITTED - * - * @param level the values are defined in java.sql.Connection - * @return true if so - * @exception SQLException if a database access error occurs - * @see Connection - */ - public boolean supportsTransactionIsolationLevel(int level) throws SQLException - { - if (level == Connection.TRANSACTION_SERIALIZABLE || - level == Connection.TRANSACTION_READ_COMMITTED) - return true; - else - return false; - } - - /** - * Are both data definition and data manipulation transactions - * supported? I checked it, and could not do a CREATE TABLE - * within a transaction, so I am assuming that we don't - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException - { - return false; - } - - /** - * Are only data manipulation statements withing a transaction - * supported? - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean supportsDataManipulationTransactionsOnly() throws SQLException - { - return true; - } - - /** - * Does a data definition statement within a transaction force - * the transaction to commit? I think this means something like: - * - * 

-   * CREATE TABLE T (A INT);
-   * INSERT INTO T (A) VALUES (2);
-   * BEGIN;
-   * UPDATE T SET A = A + 1;
-   * CREATE TABLE X (A INT);
-   * SELECT A FROM T INTO X;
-   * COMMIT;
-   *

- * - * does the CREATE TABLE call cause a commit? The answer is no. - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean dataDefinitionCausesTransactionCommit() throws SQLException - { - return false; - } - - /** - * Is a data definition statement within a transaction ignored? - * It seems to be (from experiment in previous method) - * - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean dataDefinitionIgnoredInTransactions() throws SQLException - { - return true; - } - - /** - * Get a description of stored procedures available in a catalog - * - *

Only procedure descriptions matching the schema and procedure - * name criteria are returned. They are ordered by PROCEDURE_SCHEM - * and PROCEDURE_NAME - * - *

Each procedure description has the following columns: - *

    - *
  1. PROCEDURE_CAT String => procedure catalog (may be null) - *
  2. PROCEDURE_SCHEM String => procedure schema (may be null) - *
  3. PROCEDURE_NAME String => procedure name - *
  4. Field 4 reserved (make it null) - *
  5. Field 5 reserved (make it null) - *
  6. Field 6 reserved (make it null) - *
  7. REMARKS String => explanatory comment on the procedure - *
  8. PROCEDURE_TYPE short => kind of procedure - *
      - *
    • procedureResultUnknown - May return a result - *
    • procedureNoResult - Does not return a result - *
    • procedureReturnsResult - Returns a result - *
    - *
- * - * @param catalog - a catalog name; "" retrieves those without a - * catalog; null means drop catalog name from criteria - * @param schemaParrern - a schema name pattern; "" retrieves those - * without a schema - we ignore this parameter - * @param procedureNamePattern - a procedure name pattern - * @return ResultSet - each row is a procedure description - * @exception SQLException if a database access error occurs - */ - public java.sql.ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException - { - // the field descriptors for the new ResultSet - Field f[] = new Field[8]; - java.sql.ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - byte remarks[] = defaultRemarks; - - f[0] = new Field(connection, "PROCEDURE_CAT", iVarcharOid, 32); - f[1] = new Field(connection, "PROCEDURE_SCHEM", iVarcharOid, 32); - f[2] = new Field(connection, "PROCEDURE_NAME", iVarcharOid, 32); - f[3] = f[4] = f[5] = null; // reserved, must be null for now - f[6] = new Field(connection, "REMARKS", iVarcharOid, 8192); - f[7] = new Field(connection, "PROCEDURE_TYPE", iInt2Oid, 2); - - // If the pattern is null, then set it to the default - if(procedureNamePattern==null) - procedureNamePattern="%"; - - r = connection.ExecSQL("select proname, proretset from pg_proc where proname like '"+procedureNamePattern.toLowerCase()+"' order by proname"); - - while (r.next()) - { - byte[][] tuple = new byte[8][0]; - - tuple[0] = null; // Catalog name - tuple[1] = null; // Schema name - tuple[2] = r.getBytes(1); // Procedure name - tuple[3] = tuple[4] = tuple[5] = null; // Reserved - tuple[6] = remarks; // Remarks - - if (r.getBoolean(2)) - tuple[7] = Integer.toString(java.sql.DatabaseMetaData.procedureReturnsResult).getBytes(); - else - tuple[7] = Integer.toString(java.sql.DatabaseMetaData.procedureNoResult).getBytes(); - - v.addElement(tuple); - } - return new ResultSet(connection, f, v, "OK", 1); - } - - /** - * Get a description of a catalog's stored procedure parameters - * and result columns. - * - *

Only descriptions matching the schema, procedure and parameter - * name criteria are returned. They are ordered by PROCEDURE_SCHEM - * and PROCEDURE_NAME. Within this, the return value, if any, is - * first. Next are the parameter descriptions in call order. The - * column descriptions follow in column number order. - * - *

Each row in the ResultSet is a parameter description or column - * description with the following fields: - *

    - *
  1. PROCEDURE_CAT String => procedure catalog (may be null) - *
  2. PROCEDURE_SCHEM String => procedure schema (may be null) - *
  3. PROCEDURE_NAME String => procedure name - *
  4. COLUMN_NAME String => column/parameter name - *
  5. COLUMN_TYPE Short => kind of column/parameter: - *
    • procedureColumnUnknown - nobody knows - *
    • procedureColumnIn - IN parameter - *
    • procedureColumnInOut - INOUT parameter - *
    • procedureColumnOut - OUT parameter - *
    • procedureColumnReturn - procedure return value - *
    • procedureColumnResult - result column in ResultSet - *
    - *
  6. DATA_TYPE short => SQL type from java.sql.Types - *
  7. TYPE_NAME String => SQL type name - *
  8. PRECISION int => precision - *
  9. LENGTH int => length in bytes of data - *
  10. SCALE short => scale - *
  11. RADIX short => radix - *
  12. NULLABLE short => can it contain NULL? - *
    • procedureNoNulls - does not allow NULL values - *
    • procedureNullable - allows NULL values - *
    • procedureNullableUnknown - nullability unknown - *
    • REMARKS String => comment describing parameter/column - *
- * @param catalog This is ignored in postgresql, advise this is set to null - * @param schemaPattern This is ignored in postgresql, advise this is set to null - * @param procedureNamePattern a procedure name pattern - * @param columnNamePattern a column name pattern - * @return each row is a stored procedure parameter or column description - * @exception SQLException if a database-access error occurs - * @see #getSearchStringEscape - */ - // Implementation note: This is required for Borland's JBuilder to work - public java.sql.ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException - { - if(procedureNamePattern==null) - procedureNamePattern="%"; - - if(columnNamePattern==null) - columnNamePattern="%"; - - // for now, this returns an empty result set. - Field f[] = new Field[13]; - ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("PROCEDURE_CAT"), iVarcharOid, 32); - f[1] = new Field(connection, new String("PROCEDURE_SCHEM"), iVarcharOid, 32); - f[2] = new Field(connection, new String("PROCEDURE_NAME"), iVarcharOid, 32); - f[3] = new Field(connection, new String("COLUMN_NAME"), iVarcharOid, 32); - f[4] = new Field(connection, new String("COLUMN_TYPE"), iInt2Oid, 2); - f[5] = new Field(connection, new String("DATA_TYPE"), iInt2Oid, 2); - f[6] = new Field(connection, new String("TYPE_NAME"), iVarcharOid, 32); - f[7] = new Field(connection, new String("PRECISION"), iInt4Oid, 4); - f[8] = new Field(connection, new String("LENGTH"), iInt4Oid, 4); - f[9] = new Field(connection, new String("SCALE"), iInt2Oid, 2); - f[10] = new Field(connection, new String("RADIX"), iInt2Oid, 2); - f[11] = new Field(connection, new String("NULLABLE"), iInt2Oid, 2); - f[12] = new Field(connection, new String("REMARKS"), iVarcharOid, 32); - - // add query loop here - - return new ResultSet(connection, f, v, "OK", 1); - } - - /** - * Get a description of tables available in a catalog. - * - *

Only table descriptions matching the catalog, schema, table - * name and type criteria are returned. They are ordered by - * TABLE_TYPE, TABLE_SCHEM and TABLE_NAME. - * - *

Each table description has the following columns: - * - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. TABLE_TYPE String => table type. Typical types are "TABLE", - * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL - * TEMPORARY", "ALIAS", "SYNONYM". - *
  5. REMARKS String => explanatory comment on the table - *
- * - *

The valid values for the types parameter are: - * "TABLE", "INDEX", "SEQUENCE", "SYSTEM TABLE" and "SYSTEM INDEX" - * - * @param catalog a catalog name; For postgresql, this is ignored, and - * should be set to null - * @param schemaPattern a schema name pattern; For postgresql, this is ignored, and - * should be set to null - * @param tableNamePattern a table name pattern. For all tables this should be "%" - * @param types a list of table types to include; null returns - * all types - * @return each row is a table description - * @exception SQLException if a database-access error occurs. - */ - public java.sql.ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String types[]) throws SQLException - { - // Handle default value for types - if(types==null) - types = defaultTableTypes; - - if(tableNamePattern==null) - tableNamePattern="%"; - - // the field descriptors for the new ResultSet - Field f[] = new Field[5]; - java.sql.ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("TABLE_CAT"), iVarcharOid, 32); - f[1] = new Field(connection, new String("TABLE_SCHEM"), iVarcharOid, 32); - f[2] = new Field(connection, new String("TABLE_NAME"), iVarcharOid, 32); - f[3] = new Field(connection, new String("TABLE_TYPE"), iVarcharOid, 32); - f[4] = new Field(connection, new String("REMARKS"), iVarcharOid, 32); - - // Now form the query - StringBuffer sql = new StringBuffer("select relname,oid from pg_class where ("); - boolean notFirst=false; - for(int i=0;i - // Now take the pattern into account - sql.append(") and relname like '"); - sql.append(tableNamePattern.toLowerCase()); - sql.append("'"); - - // Now run the query - r = connection.ExecSQL(sql.toString()); - - byte remarks[]; - - while (r.next()) - { - byte[][] tuple = new byte[5][0]; - - // Fetch the description for the table (if any) - java.sql.ResultSet dr = connection.ExecSQL("select description from pg_description where objoid="+r.getInt(2)); - if(((postgresql.ResultSet)dr).getTupleCount()==1) { - dr.next(); - remarks = dr.getBytes(1); - } else - remarks = defaultRemarks; - dr.close(); - - tuple[0] = null; // Catalog name - tuple[1] = null; // Schema name - tuple[2] = r.getBytes(1); // Table name - tuple[3] = null; // Table type - tuple[4] = remarks; // Remarks - v.addElement(tuple); - } - r.close(); - return new ResultSet(connection, f, v, "OK", 1); - } - - // This array contains the valid values for the types argument - // in getTables(). - // - // Each supported type consists of it's name, and the sql where - // clause to retrieve that value. - // - // IMPORTANT: the query must be enclosed in ( ) - private static final String getTableTypes[][] = { - {"TABLE", "(relkind='r' and relname !~ '^pg_')"}, - {"INDEX", "(relkind='i' and relname !~ '^pg_')"}, - {"SEQUENCE", "(relkind='S' and relname !~ '^pg_')"}, - {"SYSTEM TABLE", "(relkind='r' and relname ~ '^pg_')"}, - {"SYSTEM INDEX", "(relkind='i' and relname ~ '^pg_')"} - }; - - // These are the default tables, used when NULL is passed to getTables - // The choice of these provide the same behaviour as psql's \d - private static final String defaultTableTypes[] = { - "TABLE","INDEX","SEQUENCE" - }; - - /** - * Get the schema names available in this database. The results - * are ordered by schema name. - * - *

The schema column is: - *

    - *
  1. TABLE_SCHEM String => schema name - *
- * - * @return ResultSet each row has a single String column that is a - * schema name - */ - public java.sql.ResultSet getSchemas() throws SQLException - { - // We don't use schemas, so we simply return a single schema name "". - // - Field f[] = new Field[1]; - Vector v = new Vector(); - byte[][] tuple = new byte[1][0]; - f[0] = new Field(connection,new String("TABLE_SCHEM"),iVarcharOid,32); - tuple[0] = "".getBytes(); - v.addElement(tuple); - return new ResultSet(connection,f,v,"OK",1); - } - - /** - * Get the catalog names available in this database. The results - * are ordered by catalog name. - * - *

The catalog column is: - *

    - *
  1. TABLE_CAT String => catalog name - *
- * - * @return ResultSet each row has a single String column that is a - * catalog name - */ - public java.sql.ResultSet getCatalogs() throws SQLException - { - // We don't use catalogs, so we simply return a single catalog name "". - Field f[] = new Field[1]; - Vector v = new Vector(); - byte[][] tuple = new byte[1][0]; - f[0] = new Field(connection,new String("TABLE_CAT"),iVarcharOid,32); - tuple[0] = "".getBytes(); - v.addElement(tuple); - return new ResultSet(connection,f,v,"OK",1); - } - - /** - * Get the table types available in this database. The results - * are ordered by table type. - * - *

The table type is: - *

    - *
  1. TABLE_TYPE String => table type. Typical types are "TABLE", - * "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", - * "LOCAL TEMPORARY", "ALIAS", "SYNONYM". - *
- * - * @return ResultSet each row has a single String column that is a - * table type - */ - public java.sql.ResultSet getTableTypes() throws SQLException - { - Field f[] = new Field[1]; - Vector v = new Vector(); - byte[][] tuple = new byte[1][0]; - f[0] = new Field(connection,new String("TABLE_TYPE"),iVarcharOid,32); - for(int i=0;iOnly column descriptions matching the catalog, schema, table - * and column name criteria are returned. They are ordered by - * TABLE_SCHEM, TABLE_NAME and ORDINAL_POSITION. - * - *

Each column description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. COLUMN_NAME String => column name - *
  5. DATA_TYPE short => SQL type from java.sql.Types - *
  6. TYPE_NAME String => Data source dependent type name - *
  7. COLUMN_SIZE int => column size. For char or date - * types this is the maximum number of characters, for numeric or - * decimal types this is precision. - *
  8. BUFFER_LENGTH is not used. - *
  9. DECIMAL_DIGITS int => the number of fractional digits - *
  10. NUM_PREC_RADIX int => Radix (typically either 10 or 2) - *
  11. NULLABLE int => is NULL allowed? - *
      - *
    • columnNoNulls - might not allow NULL values - *
    • columnNullable - definitely allows NULL values - *
    • columnNullableUnknown - nullability unknown - *
    - *
  12. REMARKS String => comment describing column (may be null) - *
  13. COLUMN_DEF String => default value (may be null) - *
  14. SQL_DATA_TYPE int => unused - *
  15. SQL_DATETIME_SUB int => unused - *
  16. CHAR_OCTET_LENGTH int => for char types the - * maximum number of bytes in the column - *
  17. ORDINAL_POSITION int => index of column in table - * (starting at 1) - *
  18. IS_NULLABLE String => "NO" means column definitely - * does not allow NULL values; "YES" means the column might - * allow NULL values. An empty string means nobody knows. - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schemaPattern a schema name pattern; "" retrieves those - * without a schema - * @param tableNamePattern a table name pattern - * @param columnNamePattern a column name pattern - * @return ResultSet each row is a column description - * @see #getSearchStringEscape - */ - public java.sql.ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException - { - // the field descriptors for the new ResultSet - Field f[] = new Field[18]; - java.sql.ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("TABLE_CAT"), iVarcharOid, 32); - f[1] = new Field(connection, new String("TABLE_SCHEM"), iVarcharOid, 32); - f[2] = new Field(connection, new String("TABLE_NAME"), iVarcharOid, 32); - f[3] = new Field(connection, new String("COLUMN_NAME"), iVarcharOid, 32); - f[4] = new Field(connection, new String("DATA_TYPE"), iInt2Oid, 2); - f[5] = new Field(connection, new String("TYPE_NAME"), iVarcharOid, 32); - f[6] = new Field(connection, new String("COLUMN_SIZE"), iInt4Oid, 4); - f[7] = new Field(connection, new String("BUFFER_LENGTH"), iVarcharOid, 32); - f[8] = new Field(connection, new String("DECIMAL_DIGITS"), iInt4Oid, 4); - f[9] = new Field(connection, new String("NUM_PREC_RADIX"), iInt4Oid, 4); - f[10] = new Field(connection, new String("NULLABLE"), iInt4Oid, 4); - f[11] = new Field(connection, new String("REMARKS"), iVarcharOid, 32); - f[12] = new Field(connection, new String("COLUMN_DEF"), iVarcharOid, 32); - f[13] = new Field(connection, new String("SQL_DATA_TYPE"), iInt4Oid, 4); - f[14] = new Field(connection, new String("SQL_DATETIME_SUB"), iInt4Oid, 4); - f[15] = new Field(connection, new String("CHAR_OCTET_LENGTH"), iVarcharOid, 32); - f[16] = new Field(connection, new String("ORDINAL_POSITION"), iInt4Oid,4); - f[17] = new Field(connection, new String("IS_NULLABLE"), iVarcharOid, 32); - - // Added by Stefan Andreasen - // If the pattern are null then set them to % - if (tableNamePattern == null) tableNamePattern="%"; - if (columnNamePattern == null) columnNamePattern="%"; - - // Now form the query - // Modified by Stefan Andreasen - r = connection.ExecSQL("select a.oid,c.relname,a.attname,a.atttypid,a.attnum,a.attnotnull,a.attlen,a.atttypmod from pg_class c, pg_attribute a where a.attrelid=c.oid and c.relname like '"+tableNamePattern.toLowerCase()+"' and a.attname like '"+columnNamePattern.toLowerCase()+"' and a.attnum>0 order by c.relname,a.attnum"); - - byte remarks[]; - - while(r.next()) { - byte[][] tuple = new byte[18][0]; - - // Fetch the description for the table (if any) - java.sql.ResultSet dr = connection.ExecSQL("select description from pg_description where objoid="+r.getInt(1)); - if(((postgresql.ResultSet)dr).getTupleCount()==1) { - dr.next(); - tuple[11] = dr.getBytes(1); - } else - tuple[11] = defaultRemarks; - - dr.close(); - - tuple[0] = "".getBytes(); // Catalog name - tuple[1] = "".getBytes(); // Schema name - tuple[2] = r.getBytes(2); // Table name - tuple[3] = r.getBytes(3); // Column name - - dr = connection.ExecSQL("select typname from pg_type where oid = "+r.getString(4)); - dr.next(); - String typname=dr.getString(1); - dr.close(); - tuple[4] = Integer.toString(Field.getSQLType(typname)).getBytes(); // Data type - tuple[5] = typname.getBytes(); // Type name - - // Column size - // Looking at the psql source, - // I think the length of a varchar as specified when the table was created - // should be extracted from atttypmod which contains this length + sizeof(int32) - if (typname.equals("bpchar") || typname.equals("varchar")) { - int atttypmod = r.getInt(8); - tuple[6] = Integer.toString(atttypmod != -1 ? atttypmod - VARHDRSZ : 0).getBytes(); - } else - tuple[6] = r.getBytes(7); - - tuple[7] = null; // Buffer length - - tuple[8] = "0".getBytes(); // Decimal Digits - how to get this? - tuple[9] = "10".getBytes(); // Num Prec Radix - assume decimal - - // tuple[10] is below - // tuple[11] is above - - tuple[12] = null; // column default - - tuple[13] = null; // sql data type (unused) - tuple[14] = null; // sql datetime sub (unused) - - tuple[15] = tuple[6]; // char octet length - - tuple[16] = r.getBytes(5); // ordinal position - - String nullFlag = r.getString(6); - tuple[10] = Integer.toString(nullFlag.equals("f")?java.sql.DatabaseMetaData.columnNullable:java.sql.DatabaseMetaData.columnNoNulls).getBytes(); // Nullable - tuple[17] = (nullFlag.equals("f")?"YES":"NO").getBytes(); // is nullable - - v.addElement(tuple); - } - r.close(); - return new ResultSet(connection, f, v, "OK", 1); - } - - /** - * Get a description of the access rights for a table's columns. - * - *

Only privileges matching the column name criteria are - * returned. They are ordered by COLUMN_NAME and PRIVILEGE. - * - *

Each privilige description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. COLUMN_NAME String => column name - *
  5. GRANTOR => grantor of access (may be null) - *
  6. GRANTEE String => grantee of access - *
  7. PRIVILEGE String => name of access (SELECT, - * INSERT, UPDATE, REFRENCES, ...) - *
  8. IS_GRANTABLE String => "YES" if grantee is permitted - * to grant to others; "NO" if not; null if unknown - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name; "" retrieves those without a schema - * @param table a table name - * @param columnNamePattern a column name pattern - * @return ResultSet each row is a column privilege description - * @see #getSearchStringEscape - */ - public java.sql.ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern) throws SQLException - { - Field f[] = new Field[8]; - Vector v = new Vector(); - - if(table==null) - table="%"; - - if(columnNamePattern==null) - columnNamePattern="%"; - else - columnNamePattern=columnNamePattern.toLowerCase(); - - f[0] = new Field(connection,new String("TABLE_CAT"),iVarcharOid,32); - f[1] = new Field(connection,new String("TABLE_SCHEM"),iVarcharOid,32); - f[2] = new Field(connection,new String("TABLE_NAME"),iVarcharOid,32); - f[3] = new Field(connection,new String("COLUMN_NAME"),iVarcharOid,32); - f[4] = new Field(connection,new String("GRANTOR"),iVarcharOid,32); - f[5] = new Field(connection,new String("GRANTEE"),iVarcharOid,32); - f[6] = new Field(connection,new String("PRIVILEGE"),iVarcharOid,32); - f[7] = new Field(connection,new String("IS_GRANTABLE"),iVarcharOid,32); - - // This is taken direct from the psql source - java.sql.ResultSet r = connection.ExecSQL("SELECT relname, relacl FROM pg_class, pg_user WHERE ( relkind = 'r' OR relkind = 'i') and relname !~ '^pg_' and relname !~ '^xin[vx][0-9]+' and usesysid = relowner and relname like '"+table.toLowerCase()+"' ORDER BY relname"); - while(r.next()) { - byte[][] tuple = new byte[8][0]; - tuple[0] = tuple[1]= "".getBytes(); - DriverManager.println("relname=\""+r.getString(1)+"\" relacl=\""+r.getString(2)+"\""); - - // For now, don't add to the result as relacl needs to be processed. - //v.addElement(tuple); - } - - return new ResultSet(connection,f,v,"OK",1); - } - - /** - * Get a description of the access rights for each table available - * in a catalog. - * - *

Only privileges matching the schema and table name - * criteria are returned. They are ordered by TABLE_SCHEM, - * TABLE_NAME, and PRIVILEGE. - * - *

Each privilige description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. COLUMN_NAME String => column name - *
  5. GRANTOR => grantor of access (may be null) - *
  6. GRANTEE String => grantee of access - *
  7. PRIVILEGE String => name of access (SELECT, - * INSERT, UPDATE, REFRENCES, ...) - *
  8. IS_GRANTABLE String => "YES" if grantee is permitted - * to grant to others; "NO" if not; null if unknown - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schemaPattern a schema name pattern; "" retrieves those - * without a schema - * @param tableNamePattern a table name pattern - * @return ResultSet each row is a table privilege description - * @see #getSearchStringEscape - */ - public java.sql.ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of a table's optimal set of columns that - * uniquely identifies a row. They are ordered by SCOPE. - * - *

Each column description has the following columns: - *

    - *
  1. SCOPE short => actual scope of result - *
      - *
    • bestRowTemporary - very temporary, while using row - *
    • bestRowTransaction - valid for remainder of current transaction - *
    • bestRowSession - valid for remainder of current session - *
    - *
  2. COLUMN_NAME String => column name - *
  3. DATA_TYPE short => SQL data type from java.sql.Types - *
  4. TYPE_NAME String => Data source dependent type name - *
  5. COLUMN_SIZE int => precision - *
  6. BUFFER_LENGTH int => not used - *
  7. DECIMAL_DIGITS short => scale - *
  8. PSEUDO_COLUMN short => is this a pseudo column - * like an Oracle ROWID - *
      - *
    • bestRowUnknown - may or may not be pseudo column - *
    • bestRowNotPseudo - is NOT a pseudo column - *
    • bestRowPseudo - is a pseudo column - *
    - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name; "" retrieves those without a schema - * @param table a table name - * @param scope the scope of interest; use same values as SCOPE - * @param nullable include columns that are nullable? - * @return ResultSet each row is a column description - */ - // Implementation note: This is required for Borland's JBuilder to work - public java.sql.ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable) throws SQLException - { - // for now, this returns an empty result set. - Field f[] = new Field[8]; - ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("SCOPE"), iInt2Oid, 2); - f[1] = new Field(connection, new String("COLUMN_NAME"), iVarcharOid, 32); - f[2] = new Field(connection, new String("DATA_TYPE"), iInt2Oid, 2); - f[3] = new Field(connection, new String("TYPE_NAME"), iVarcharOid, 32); - f[4] = new Field(connection, new String("COLUMN_SIZE"), iInt4Oid, 4); - f[5] = new Field(connection, new String("BUFFER_LENGTH"), iInt4Oid, 4); - f[6] = new Field(connection, new String("DECIMAL_DIGITS"), iInt2Oid, 2); - f[7] = new Field(connection, new String("PSEUDO_COLUMN"), iInt2Oid, 2); - - return new ResultSet(connection, f, v, "OK", 1); - } - - /** - * Get a description of a table's columns that are automatically - * updated when any value in a row is updated. They are - * unordered. - * - *

Each column description has the following columns: - *

    - *
  1. SCOPE short => is not used - *
  2. COLUMN_NAME String => column name - *
  3. DATA_TYPE short => SQL data type from java.sql.Types - *
  4. TYPE_NAME String => Data source dependent type name - *
  5. COLUMN_SIZE int => precision - *
  6. BUFFER_LENGTH int => length of column value in bytes - *
  7. DECIMAL_DIGITS short => scale - *
  8. PSEUDO_COLUMN short => is this a pseudo column - * like an Oracle ROWID - *
      - *
    • versionColumnUnknown - may or may not be pseudo column - *
    • versionColumnNotPseudo - is NOT a pseudo column - *
    • versionColumnPseudo - is a pseudo column - *
    - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name; "" retrieves those without a schema - * @param table a table name - * @return ResultSet each row is a column description - */ - public java.sql.ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of a table's primary key columns. They - * are ordered by COLUMN_NAME. - * - *

Each column description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. COLUMN_NAME String => column name - *
  5. KEY_SEQ short => sequence number within primary key - *
  6. PK_NAME String => primary key name (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those - * without a schema - * @param table a table name - * @return ResultSet each row is a primary key column description - */ - public java.sql.ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException - { - return connection.createStatement().executeQuery("SELECT " + - "'' as TABLE_CAT," + - "'' AS TABLE_SCHEM," + - "bc.relname AS TABLE_NAME," + - "a.attname AS COLUMN_NAME," + - "a.attnum as KEY_SEQ,"+ - "ic.relname as PK_NAME " + - " FROM pg_class bc, pg_class ic, pg_index i, pg_attribute a" + - " WHERE bc.relkind = 'r' " + // -- not indices - " and upper(bc.relname) = upper('"+table+"')" + - " and i.indrelid = bc.oid" + - " and i.indexrelid = ic.oid" + - " and ic.oid = a.attrelid" + - " and i.indisprimary='t' " + - " ORDER BY table_name, pk_name, key_seq" - ); - } - - /** - * Get a description of the primary key columns that are - * referenced by a table's foreign key columns (the primary keys - * imported by a table). They are ordered by PKTABLE_CAT, - * PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ. - * - *

Each primary key column description has the following columns: - *

    - *
  1. PKTABLE_CAT String => primary key table catalog - * being imported (may be null) - *
  2. PKTABLE_SCHEM String => primary key table schema - * being imported (may be null) - *
  3. PKTABLE_NAME String => primary key table name - * being imported - *
  4. PKCOLUMN_NAME String => primary key column name - * being imported - *
  5. FKTABLE_CAT String => foreign key table catalog (may be null) - *
  6. FKTABLE_SCHEM String => foreign key table schema (may be null) - *
  7. FKTABLE_NAME String => foreign key table name - *
  8. FKCOLUMN_NAME String => foreign key column name - *
  9. KEY_SEQ short => sequence number within foreign key - *
  10. UPDATE_RULE short => What happens to - * foreign key when primary is updated: - *
      - *
    • importedKeyCascade - change imported key to agree - * with primary key update - *
    • importedKeyRestrict - do not allow update of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been updated - *
    - *
  11. DELETE_RULE short => What happens to - * the foreign key when primary is deleted. - *
      - *
    • importedKeyCascade - delete rows that import a deleted key - *
    • importedKeyRestrict - do not allow delete of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been deleted - *
    - *
  12. FK_NAME String => foreign key name (may be null) - *
  13. PK_NAME String => primary key name (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those - * without a schema - * @param table a table name - * @return ResultSet each row is a primary key column description - * @see #getExportedKeys - */ - public java.sql.ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of a foreign key columns that reference a - * table's primary key columns (the foreign keys exported by a - * table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM, - * FKTABLE_NAME, and KEY_SEQ. - * - *

Each foreign key column description has the following columns: - *

    - *
  1. PKTABLE_CAT String => primary key table catalog (may be null) - *
  2. PKTABLE_SCHEM String => primary key table schema (may be null) - *
  3. PKTABLE_NAME String => primary key table name - *
  4. PKCOLUMN_NAME String => primary key column name - *
  5. FKTABLE_CAT String => foreign key table catalog (may be null) - * being exported (may be null) - *
  6. FKTABLE_SCHEM String => foreign key table schema (may be null) - * being exported (may be null) - *
  7. FKTABLE_NAME String => foreign key table name - * being exported - *
  8. FKCOLUMN_NAME String => foreign key column name - * being exported - *
  9. KEY_SEQ short => sequence number within foreign key - *
  10. UPDATE_RULE short => What happens to - * foreign key when primary is updated: - *
      - *
    • importedKeyCascade - change imported key to agree - * with primary key update - *
    • importedKeyRestrict - do not allow update of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been updated - *
    - *
  11. DELETE_RULE short => What happens to - * the foreign key when primary is deleted. - *
      - *
    • importedKeyCascade - delete rows that import a deleted key - *
    • importedKeyRestrict - do not allow delete of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been deleted - *
    - *
  12. FK_NAME String => foreign key identifier (may be null) - *
  13. PK_NAME String => primary key identifier (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those - * without a schema - * @param table a table name - * @return ResultSet each row is a foreign key column description - * @see #getImportedKeys - */ - public java.sql.ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of the foreign key columns in the foreign key - * table that reference the primary key columns of the primary key - * table (describe how one table imports another's key.) This - * should normally return a single foreign key/primary key pair - * (most tables only import a foreign key from a table once.) They - * are ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and - * KEY_SEQ. - * - *

Each foreign key column description has the following columns: - *

    - *
  1. PKTABLE_CAT String => primary key table catalog (may be null) - *
  2. PKTABLE_SCHEM String => primary key table schema (may be null) - *
  3. PKTABLE_NAME String => primary key table name - *
  4. PKCOLUMN_NAME String => primary key column name - *
  5. FKTABLE_CAT String => foreign key table catalog (may be null) - * being exported (may be null) - *
  6. FKTABLE_SCHEM String => foreign key table schema (may be null) - * being exported (may be null) - *
  7. FKTABLE_NAME String => foreign key table name - * being exported - *
  8. FKCOLUMN_NAME String => foreign key column name - * being exported - *
  9. KEY_SEQ short => sequence number within foreign key - *
  10. UPDATE_RULE short => What happens to - * foreign key when primary is updated: - *
      - *
    • importedKeyCascade - change imported key to agree - * with primary key update - *
    • importedKeyRestrict - do not allow update of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been updated - *
    - *
  11. DELETE_RULE short => What happens to - * the foreign key when primary is deleted. - *
      - *
    • importedKeyCascade - delete rows that import a deleted key - *
    • importedKeyRestrict - do not allow delete of primary - * key if it has been imported - *
    • importedKeySetNull - change imported key to NULL if - * its primary key has been deleted - *
    - *
  12. FK_NAME String => foreign key identifier (may be null) - *
  13. PK_NAME String => primary key identifier (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those - * without a schema - * @param table a table name - * @return ResultSet each row is a foreign key column description - * @see #getImportedKeys - */ - public java.sql.ResultSet getCrossReference(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException - { - // XXX-Not Implemented - return null; - } - - /** - * Get a description of all the standard SQL types supported by - * this database. They are ordered by DATA_TYPE and then by how - * closely the data type maps to the corresponding JDBC SQL type. - * - *

Each type description has the following columns: - *

    - *
  1. TYPE_NAME String => Type name - *
  2. DATA_TYPE short => SQL data type from java.sql.Types - *
  3. PRECISION int => maximum precision - *
  4. LITERAL_PREFIX String => prefix used to quote a literal - * (may be null) - *
  5. LITERAL_SUFFIX String => suffix used to quote a literal - (may be null) - *
  6. CREATE_PARAMS String => parameters used in creating - * the type (may be null) - *
  7. NULLABLE short => can you use NULL for this type? - *
      - *
    • typeNoNulls - does not allow NULL values - *
    • typeNullable - allows NULL values - *
    • typeNullableUnknown - nullability unknown - *
    - *
  8. CASE_SENSITIVE boolean=> is it case sensitive? - *
  9. SEARCHABLE short => can you use "WHERE" based on this type: - *
      - *
    • typePredNone - No support - *
    • typePredChar - Only supported with WHERE .. LIKE - *
    • typePredBasic - Supported except for WHERE .. LIKE - *
    • typeSearchable - Supported for all WHERE .. - *
    - *
  10. UNSIGNED_ATTRIBUTE boolean => is it unsigned? - *
  11. FIXED_PREC_SCALE boolean => can it be a money value? - *
  12. AUTO_INCREMENT boolean => can it be used for an - * auto-increment value? - *
  13. LOCAL_TYPE_NAME String => localized version of type name - * (may be null) - *
  14. MINIMUM_SCALE short => minimum scale supported - *
  15. MAXIMUM_SCALE short => maximum scale supported - *
  16. SQL_DATA_TYPE int => unused - *
  17. SQL_DATETIME_SUB int => unused - *
  18. NUM_PREC_RADIX int => usually 2 or 10 - *
- * - * @return ResultSet each row is a SQL type description - */ - public java.sql.ResultSet getTypeInfo() throws SQLException - { - java.sql.ResultSet rs = connection.ExecSQL("select typname from pg_type"); - if(rs!=null) { - Field f[] = new Field[18]; - ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("TYPE_NAME"), iVarcharOid, 32); - f[1] = new Field(connection, new String("DATA_TYPE"), iInt2Oid, 2); - f[2] = new Field(connection, new String("PRECISION"), iInt4Oid, 4); - f[3] = new Field(connection, new String("LITERAL_PREFIX"), iVarcharOid, 32); - f[4] = new Field(connection, new String("LITERAL_SUFFIX"), iVarcharOid, 32); - f[5] = new Field(connection, new String("CREATE_PARAMS"), iVarcharOid, 32); - f[6] = new Field(connection, new String("NULLABLE"), iInt2Oid, 2); - f[7] = new Field(connection, new String("CASE_SENSITIVE"), iBoolOid, 1); - f[8] = new Field(connection, new String("SEARCHABLE"), iInt2Oid, 2); - f[9] = new Field(connection, new String("UNSIGNED_ATTRIBUTE"), iBoolOid, 1); - f[10] = new Field(connection, new String("FIXED_PREC_SCALE"), iBoolOid, 1); - f[11] = new Field(connection, new String("AUTO_INCREMENT"), iBoolOid, 1); - f[12] = new Field(connection, new String("LOCAL_TYPE_NAME"), iVarcharOid, 32); - f[13] = new Field(connection, new String("MINIMUM_SCALE"), iInt2Oid, 2); - f[14] = new Field(connection, new String("MAXIMUM_SCALE"), iInt2Oid, 2); - f[15] = new Field(connection, new String("SQL_DATA_TYPE"), iInt4Oid, 4); - f[16] = new Field(connection, new String("SQL_DATETIME_SUB"), iInt4Oid, 4); - f[17] = new Field(connection, new String("NUM_PREC_RADIX"), iInt4Oid, 4); - - // cache some results, this will keep memory useage down, and speed - // things up a little. - byte b9[] = "9".getBytes(); - byte b10[] = "10".getBytes(); - byte bf[] = "f".getBytes(); - byte bnn[] = Integer.toString(typeNoNulls).getBytes(); - byte bts[] = Integer.toString(typeSearchable).getBytes(); - - while(rs.next()) { - byte[][] tuple = new byte[18][]; - String typname=rs.getString(1); - tuple[0] = typname.getBytes(); - tuple[1] = Integer.toString(Field.getSQLType(typname)).getBytes(); - tuple[2] = b9; // for now - tuple[6] = bnn; // for now - tuple[7] = bf; // false for now - not case sensitive - tuple[8] = bts; - tuple[9] = bf; // false for now - it's signed - tuple[10] = bf; // false for now - must handle money - tuple[11] = bf; // false for now - handle autoincrement - // 12 - LOCAL_TYPE_NAME is null - // 13 & 14 ? - // 15 & 16 are unused so we return null - tuple[17] = b10; // everything is base 10 - v.addElement(tuple); - } - rs.close(); - return new ResultSet(connection, f, v, "OK", 1); - } - - return null; - } - - /** - * Get a description of a table's indices and statistics. They are - * ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION. - * - *

Each index column description has the following columns: - *

    - *
  1. TABLE_CAT String => table catalog (may be null) - *
  2. TABLE_SCHEM String => table schema (may be null) - *
  3. TABLE_NAME String => table name - *
  4. NON_UNIQUE boolean => Can index values be non-unique? - * false when TYPE is tableIndexStatistic - *
  5. INDEX_QUALIFIER String => index catalog (may be null); - * null when TYPE is tableIndexStatistic - *
  6. INDEX_NAME String => index name; null when TYPE is - * tableIndexStatistic - *
  7. TYPE short => index type: - *
      - *
    • tableIndexStatistic - this identifies table statistics that are - * returned in conjuction with a table's index descriptions - *
    • tableIndexClustered - this is a clustered index - *
    • tableIndexHashed - this is a hashed index - *
    • tableIndexOther - this is some other style of index - *
    - *
  8. ORDINAL_POSITION short => column sequence number - * within index; zero when TYPE is tableIndexStatistic - *
  9. COLUMN_NAME String => column name; null when TYPE is - * tableIndexStatistic - *
  10. ASC_OR_DESC String => column sort sequence, "A" => ascending - * "D" => descending, may be null if sort sequence is not supported; - * null when TYPE is tableIndexStatistic - *
  11. CARDINALITY int => When TYPE is tableIndexStatisic then - * this is the number of rows in the table; otherwise it is the - * number of unique values in the index. - *
  12. PAGES int => When TYPE is tableIndexStatisic then - * this is the number of pages used for the table, otherwise it - * is the number of pages used for the current index. - *
  13. FILTER_CONDITION String => Filter condition, if any. - * (may be null) - *
- * - * @param catalog a catalog name; "" retrieves those without a catalog - * @param schema a schema name pattern; "" retrieves those without a schema - * @param table a table name - * @param unique when true, return only indices for unique values; - * when false, return indices regardless of whether unique or not - * @param approximate when true, result is allowed to reflect approximate - * or out of data values; when false, results are requested to be - * accurate - * @return ResultSet each row is an index column description - */ - // Implementation note: This is required for Borland's JBuilder to work - public java.sql.ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate) throws SQLException - { - // for now, this returns an empty result set. - Field f[] = new Field[13]; - ResultSet r; // ResultSet for the SQL query that we need to do - Vector v = new Vector(); // The new ResultSet tuple stuff - - f[0] = new Field(connection, new String("TABLE_CAT"), iVarcharOid, 32); - f[1] = new Field(connection, new String("TABLE_SCHEM"), iVarcharOid, 32); - f[2] = new Field(connection, new String("TABLE_NAME"), iVarcharOid, 32); - f[3] = new Field(connection, new String("NON_UNIQUE"), iBoolOid, 1); - f[4] = new Field(connection, new String("INDEX_QUALIFIER"), iVarcharOid, 32); - f[5] = new Field(connection, new String("INDEX_NAME"), iVarcharOid, 32); - f[6] = new Field(connection, new String("TYPE"), iInt2Oid, 2); - f[7] = new Field(connection, new String("ORDINAL_POSITION"), iInt2Oid, 2); - f[8] = new Field(connection, new String("COLUMN_NAME"), iVarcharOid, 32); - f[9] = new Field(connection, new String("ASC_OR_DESC"), iVarcharOid, 32); - f[10] = new Field(connection, new String("CARDINALITY"), iInt4Oid, 4); - f[11] = new Field(connection, new String("PAGES"), iInt4Oid, 4); - f[12] = new Field(connection, new String("FILTER_CONDITION"), iVarcharOid, 32); - - return new ResultSet(connection, f, v, "OK", 1); - } - - // ** JDBC 2 Extensions ** - - public boolean deletesAreDetected(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean othersDeletesAreVisible(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Class getClass(String catalog, - String schema, - String table, - String columnNamePattern - ) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.sql.Connection getConnection() throws SQLException - { - return (java.sql.Connection)connection; - } - - public java.sql.ResultSet getUDTs(String catalog, - String schemaPattern, - String typeNamePattern, - int[] types - ) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean othersInsertsAreVisible(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean updatesAreDetected(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean othersUpdatesAreVisible(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean ownUpdatesAreVisible(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean ownInsertsAreVisible(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean insertsAreDetected(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean ownDeletesAreVisible(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean rowChangesAreDetected(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean rowChangesAreVisible(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean supportsBatchUpdates() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean supportsResultSetConcurrency(int type,int concurrency) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean supportsResultSetType(int type) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - -} - diff --git a/src/interfaces/jdbc/postgresql/jdbc2/PreparedStatement.java b/src/interfaces/jdbc/postgresql/jdbc2/PreparedStatement.java deleted file mode 100644 index b0011aa36f..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc2/PreparedStatement.java +++ /dev/null @@ -1,661 +0,0 @@ -package postgresql.jdbc2; - -// IMPORTANT NOTE: This file implements the JDBC 2 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 1 class in the -// postgresql.jdbc1 package. - -import java.io.*; -import java.math.*; -import java.sql.*; -import java.text.*; -import java.util.*; -import postgresql.largeobject.*; -import postgresql.util.*; - -/** - * A SQL Statement is pre-compiled and stored in a PreparedStatement object. - * This object can then be used to efficiently execute this statement multiple - * times. - * - *

Note: The setXXX methods for setting IN parameter values must - * specify types that are compatible with the defined SQL type of the input - * parameter. For instance, if the IN parameter has SQL type Integer, then - * setInt should be used. - * - *

If arbitrary parameter type conversions are required, then the setObject - * method should be used with a target SQL type. - * - * @see ResultSet - * @see java.sql.PreparedStatement - */ -public class PreparedStatement extends Statement implements java.sql.PreparedStatement -{ - String sql; - String[] templateStrings; - String[] inStrings; - Connection connection; - - /** - * Constructor for the PreparedStatement class. - * Split the SQL statement into segments - separated by the arguments. - * When we rebuild the thing with the arguments, we can substitute the - * args and join the whole thing together. - * - * @param conn the instanatiating connection - * @param sql the SQL statement with ? for IN markers - * @exception SQLException if something bad occurs - */ - public PreparedStatement(Connection connection, String sql) throws SQLException - { - super(connection); - - Vector v = new Vector(); - boolean inQuotes = false; - int lastParmEnd = 0, i; - - this.sql = sql; - this.connection = connection; - for (i = 0; i < sql.length(); ++i) - { - int c = sql.charAt(i); - - if (c == '\'') - inQuotes = !inQuotes; - if (c == '?' && !inQuotes) - { - v.addElement(sql.substring (lastParmEnd, i)); - lastParmEnd = i + 1; - } - } - v.addElement(sql.substring (lastParmEnd, sql.length())); - - templateStrings = new String[v.size()]; - inStrings = new String[v.size() - 1]; - clearParameters(); - - for (i = 0 ; i < templateStrings.length; ++i) - templateStrings[i] = (String)v.elementAt(i); - } - - /** - * A Prepared SQL query is executed and its ResultSet is returned - * - * @return a ResultSet that contains the data produced by the - * query - never null - * @exception SQLException if a database access error occurs - */ - public java.sql.ResultSet executeQuery() throws SQLException - { - StringBuffer s = new StringBuffer(); - int i; - - for (i = 0 ; i < inStrings.length ; ++i) - { - if (inStrings[i] == null) - throw new PSQLException("postgresql.prep.param",new Integer(i + 1)); - s.append (templateStrings[i]); - s.append (inStrings[i]); - } - s.append(templateStrings[inStrings.length]); - return super.executeQuery(s.toString()); // in Statement class - } - - /** - * Execute a SQL INSERT, UPDATE or DELETE statement. In addition, - * SQL statements that return nothing such as SQL DDL statements can - * be executed. - * - * @return either the row count for INSERT, UPDATE or DELETE; or - * 0 for SQL statements that return nothing. - * @exception SQLException if a database access error occurs - */ - public int executeUpdate() throws SQLException - { - StringBuffer s = new StringBuffer(); - int i; - - for (i = 0 ; i < inStrings.length ; ++i) - { - if (inStrings[i] == null) - throw new PSQLException("postgresql.prep.param",new Integer(i + 1)); - s.append (templateStrings[i]); - s.append (inStrings[i]); - } - s.append(templateStrings[inStrings.length]); - return super.executeUpdate(s.toString()); // in Statement class - } - - /** - * Set a parameter to SQL NULL - * - *

Note: You must specify the parameters SQL type (although - * PostgreSQL ignores it) - * - * @param parameterIndex the first parameter is 1, etc... - * @param sqlType the SQL type code defined in java.sql.Types - * @exception SQLException if a database access error occurs - */ - public void setNull(int parameterIndex, int sqlType) throws SQLException - { - set(parameterIndex, "null"); - } - - /** - * Set a parameter to a Java boolean value. The driver converts this - * to a SQL BIT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setBoolean(int parameterIndex, boolean x) throws SQLException - { - set(parameterIndex, x ? "'t'" : "'f'"); - } - - /** - * Set a parameter to a Java byte value. The driver converts this to - * a SQL TINYINT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setByte(int parameterIndex, byte x) throws SQLException - { - set(parameterIndex, (new Integer(x)).toString()); - } - - /** - * Set a parameter to a Java short value. The driver converts this - * to a SQL SMALLINT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setShort(int parameterIndex, short x) throws SQLException - { - set(parameterIndex, (new Integer(x)).toString()); - } - - /** - * Set a parameter to a Java int value. The driver converts this to - * a SQL INTEGER value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setInt(int parameterIndex, int x) throws SQLException - { - set(parameterIndex, (new Integer(x)).toString()); - } - - /** - * Set a parameter to a Java long value. The driver converts this to - * a SQL BIGINT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setLong(int parameterIndex, long x) throws SQLException - { - set(parameterIndex, (new Long(x)).toString()); - } - - /** - * Set a parameter to a Java float value. The driver converts this - * to a SQL FLOAT value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setFloat(int parameterIndex, float x) throws SQLException - { - set(parameterIndex, (new Float(x)).toString()); - } - - /** - * Set a parameter to a Java double value. The driver converts this - * to a SQL DOUBLE value when it sends it to the database - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setDouble(int parameterIndex, double x) throws SQLException - { - set(parameterIndex, (new Double(x)).toString()); - } - - /** - * Set a parameter to a java.lang.BigDecimal value. The driver - * converts this to a SQL NUMERIC value when it sends it to the - * database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException - { - set(parameterIndex, x.toString()); - } - - /** - * Set a parameter to a Java String value. The driver converts this - * to a SQL VARCHAR or LONGVARCHAR value (depending on the arguments - * size relative to the driver's limits on VARCHARs) when it sends it - * to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setString(int parameterIndex, String x) throws SQLException - { - // if the passed string is null, then set this column to null - if(x==null) - set(parameterIndex,"null"); - else { - StringBuffer b = new StringBuffer(); - int i; - - b.append('\''); - for (i = 0 ; i < x.length() ; ++i) - { - char c = x.charAt(i); - if (c == '\\' || c == '\'') - b.append((char)'\\'); - b.append(c); - } - b.append('\''); - set(parameterIndex, b.toString()); - } - } - - /** - * Set a parameter to a Java array of bytes. The driver converts this - * to a SQL VARBINARY or LONGVARBINARY (depending on the argument's - * size relative to the driver's limits on VARBINARYs) when it sends - * it to the database. - * - *

Implementation note: - *
With postgresql, this creates a large object, and stores the - * objects oid in this column. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setBytes(int parameterIndex, byte x[]) throws SQLException - { - LargeObjectManager lom = connection.getLargeObjectAPI(); - int oid = lom.create(); - LargeObject lob = lom.open(oid); - lob.write(x); - lob.close(); - setInt(parameterIndex,oid); - } - - /** - * Set a parameter to a java.sql.Date value. The driver converts this - * to a SQL DATE value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setDate(int parameterIndex, java.sql.Date x) throws SQLException - { - SimpleDateFormat df = new SimpleDateFormat("''yyyy-MM-dd''"); - - set(parameterIndex, df.format(x)); - - // The above is how the date should be handled. - // - // However, in JDK's prior to 1.1.6 (confirmed with the - // Linux jdk1.1.3 and the Win95 JRE1.1.5), SimpleDateFormat seems - // to format a date to the previous day. So the fix is to add a day - // before formatting. - // - // PS: 86400000 is one day - // - //set(parameterIndex, df.format(new java.util.Date(x.getTime()+86400000))); - } - - /** - * Set a parameter to a java.sql.Time value. The driver converts - * this to a SQL TIME value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1...)); - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setTime(int parameterIndex, Time x) throws SQLException - { - set(parameterIndex, "'" + x.toString() + "'"); - } - - /** - * Set a parameter to a java.sql.Timestamp value. The driver converts - * this to a SQL TIMESTAMP value when it sends it to the database. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException - { - set(parameterIndex, "'" + x.toString() + "'"); - } - - /** - * When a very large ASCII value is input to a LONGVARCHAR parameter, - * it may be more practical to send it via a java.io.InputStream. - * JDBC will read the data from the stream as needed, until it reaches - * end-of-file. The JDBC driver will do any necessary conversion from - * ASCII to the database char format. - * - *

Note: This stream object can either be a standard Java - * stream object or your own subclass that implements the standard - * interface. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @param length the number of bytes in the stream - * @exception SQLException if a database access error occurs - */ - public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException - { - setBinaryStream(parameterIndex, x, length); - } - - /** - * When a very large Unicode value is input to a LONGVARCHAR parameter, - * it may be more practical to send it via a java.io.InputStream. - * JDBC will read the data from the stream as needed, until it reaches - * end-of-file. The JDBC driver will do any necessary conversion from - * UNICODE to the database char format. - * - * ** DEPRECIATED IN JDBC 2 ** - * - *

Note: This stream object can either be a standard Java - * stream object or your own subclass that implements the standard - * interface. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - * @deprecated - */ - public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException - { - setBinaryStream(parameterIndex, x, length); - } - - /** - * When a very large binary value is input to a LONGVARBINARY parameter, - * it may be more practical to send it via a java.io.InputStream. - * JDBC will read the data from the stream as needed, until it reaches - * end-of-file. - * - *

Note: This stream object can either be a standard Java - * stream object or your own subclass that implements the standard - * interface. - * - * @param parameterIndex the first parameter is 1... - * @param x the parameter value - * @exception SQLException if a database access error occurs - */ - public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException - { - throw new PSQLException("postgresql.prep.is"); - } - - /** - * In general, parameter values remain in force for repeated used of a - * Statement. Setting a parameter value automatically clears its - * previous value. However, in coms cases, it is useful to immediately - * release the resources used by the current parameter values; this - * can be done by calling clearParameters - * - * @exception SQLException if a database access error occurs - */ - public void clearParameters() throws SQLException - { - int i; - - for (i = 0 ; i < inStrings.length ; i++) - inStrings[i] = null; - } - - /** - * Set the value of a parameter using an object; use the java.lang - * equivalent objects for integral values. - * - *

The given Java object will be converted to the targetSqlType before - * being sent to the database. - * - *

note that this method may be used to pass database-specific - * abstract data types. This is done by using a Driver-specific - * Java type and using a targetSqlType of java.sql.Types.OTHER - * - * @param parameterIndex the first parameter is 1... - * @param x the object containing the input parameter value - * @param targetSqlType The SQL type to be send to the database - * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC - * types this is the number of digits after the decimal. For - * all other types this value will be ignored. - * @exception SQLException if a database access error occurs - */ - public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException - { - switch (targetSqlType) - { - case Types.TINYINT: - case Types.SMALLINT: - case Types.INTEGER: - case Types.BIGINT: - case Types.REAL: - case Types.FLOAT: - case Types.DOUBLE: - case Types.DECIMAL: - case Types.NUMERIC: - if (x instanceof Boolean) - set(parameterIndex, ((Boolean)x).booleanValue() ? "1" : "0"); - else - set(parameterIndex, x.toString()); - break; - case Types.CHAR: - case Types.VARCHAR: - case Types.LONGVARCHAR: - setString(parameterIndex, x.toString()); - break; - case Types.DATE: - setDate(parameterIndex, (java.sql.Date)x); - break; - case Types.TIME: - setTime(parameterIndex, (Time)x); - break; - case Types.TIMESTAMP: - setTimestamp(parameterIndex, (Timestamp)x); - break; - case Types.OTHER: - setString(parameterIndex, ((PGobject)x).getValue()); - break; - default: - throw new PSQLException("postgresql.prep.type"); - } - } - - public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException - { - setObject(parameterIndex, x, targetSqlType, 0); - } - - /** - * This stores an Object into a parameter. - *

New for 6.4, if the object is not recognised, but it is - * Serializable, then the object is serialised using the - * postgresql.util.Serialize class. - */ - public void setObject(int parameterIndex, Object x) throws SQLException - { - if (x instanceof String) - setString(parameterIndex, (String)x); - else if (x instanceof BigDecimal) - setBigDecimal(parameterIndex, (BigDecimal)x); - else if (x instanceof Short) - setShort(parameterIndex, ((Short)x).shortValue()); - else if (x instanceof Integer) - setInt(parameterIndex, ((Integer)x).intValue()); - else if (x instanceof Long) - setLong(parameterIndex, ((Long)x).longValue()); - else if (x instanceof Float) - setFloat(parameterIndex, ((Float)x).floatValue()); - else if (x instanceof Double) - setDouble(parameterIndex, ((Double)x).doubleValue()); - else if (x instanceof byte[]) - setBytes(parameterIndex, (byte[])x); - else if (x instanceof java.sql.Date) - setDate(parameterIndex, (java.sql.Date)x); - else if (x instanceof Time) - setTime(parameterIndex, (Time)x); - else if (x instanceof Timestamp) - setTimestamp(parameterIndex, (Timestamp)x); - else if (x instanceof Boolean) - setBoolean(parameterIndex, ((Boolean)x).booleanValue()); - else if (x instanceof PGobject) - setString(parameterIndex, ((PGobject)x).getValue()); - else - setLong(parameterIndex, connection.putObject(x)); - } - - /** - * Some prepared statements return multiple results; the execute method - * handles these complex statements as well as the simpler form of - * statements handled by executeQuery and executeUpdate - * - * @return true if the next result is a ResultSet; false if it is an - * update count or there are no more results - * @exception SQLException if a database access error occurs - */ - public boolean execute() throws SQLException - { - StringBuffer s = new StringBuffer(); - int i; - - for (i = 0 ; i < inStrings.length ; ++i) - { - if (inStrings[i] == null) - throw new PSQLException("postgresql.prep.param",new Integer(i + 1)); - s.append (templateStrings[i]); - s.append (inStrings[i]); - } - s.append(templateStrings[inStrings.length]); - return super.execute(s.toString()); // in Statement class - } - - /** - * Returns the SQL statement with the current template values - * substituted. - */ - public String toString() { - StringBuffer s = new StringBuffer(); - int i; - - for (i = 0 ; i < inStrings.length ; ++i) - { - if (inStrings[i] == null) - s.append( '?' ); - else - s.append (templateStrings[i]); - s.append (inStrings[i]); - } - s.append(templateStrings[inStrings.length]); - return s.toString(); - } - - // ************************************************************** - // END OF PUBLIC INTERFACE - // ************************************************************** - - /** - * There are a lot of setXXX classes which all basically do - * the same thing. We need a method which actually does the - * set for us. - * - * @param paramIndex the index into the inString - * @param s a string to be stored - * @exception SQLException if something goes wrong - */ - private void set(int paramIndex, String s) throws SQLException - { - if (paramIndex < 1 || paramIndex > inStrings.length) - throw new PSQLException("postgresql.prep.range"); - inStrings[paramIndex - 1] = s; - } - - // ** JDBC 2 Extensions ** - - public void addBatch() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.sql.ResultSetMetaData getMetaData() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setArray(int i,Array x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setBlob(int i,Blob x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setCharacterStream(int i,java.io.Reader x,int length) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setClob(int i,Clob x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setNull(int i,int t,String s) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setRef(int i,Ref x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setDate(int i,java.sql.Date d,java.util.Calendar cal) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setTime(int i,Time t,java.util.Calendar cal) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setTimestamp(int i,Timestamp t,java.util.Calendar cal) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - -} diff --git a/src/interfaces/jdbc/postgresql/jdbc2/ResultSet.java b/src/interfaces/jdbc/postgresql/jdbc2/ResultSet.java deleted file mode 100644 index f41b8f0452..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc2/ResultSet.java +++ /dev/null @@ -1,1267 +0,0 @@ -package postgresql.jdbc2; - -// IMPORTANT NOTE: This file implements the JDBC 2 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 1 class in the -// postgresql.jdbc1 package. - - -import java.lang.*; -import java.io.*; -import java.math.*; -import java.text.*; -import java.util.*; -import java.sql.*; -import postgresql.Field; -import postgresql.largeobject.*; -import postgresql.util.*; - -/** - * A ResultSet provides access to a table of data generated by executing a - * Statement. The table rows are retrieved in sequence. Within a row its - * column values can be accessed in any order. - * - *

A ResultSet maintains a cursor pointing to its current row of data. - * Initially the cursor is positioned before the first row. The 'next' - * method moves the cursor to the next row. - * - *

The getXXX methods retrieve column values for the current row. You can - * retrieve values either using the index number of the column, or by using - * the name of the column. In general using the column index will be more - * efficient. Columns are numbered from 1. - * - *

For maximum portability, ResultSet columns within each row should be read - * in left-to-right order and each column should be read only once. - * - *

For the getXXX methods, the JDBC driver attempts to convert the - * underlying data to the specified Java type and returns a suitable Java - * value. See the JDBC specification for allowable mappings from SQL types - * to Java types with the ResultSet getXXX methods. - * - *

Column names used as input to getXXX methods are case insenstive. When - * performing a getXXX using a column name, if several columns have the same - * name, then the value of the first matching column will be returned. The - * column name option is designed to be used when column names are used in the - * SQL Query. For columns that are NOT explicitly named in the query, it is - * best to use column numbers. If column names were used there is no way for - * the programmer to guarentee that they actually refer to the intended - * columns. - * - *

A ResultSet is automatically closed by the Statement that generated it - * when that Statement is closed, re-executed, or is used to retrieve the - * next result from a sequence of multiple results. - * - *

The number, types and properties of a ResultSet's columns are provided by - * the ResultSetMetaData object returned by the getMetaData method. - * - * @see ResultSetMetaData - * @see java.sql.ResultSet - */ -public class ResultSet extends postgresql.ResultSet implements java.sql.ResultSet -{ - /** - * Create a new ResultSet - Note that we create ResultSets to - * represent the results of everything. - * - * @param fields an array of Field objects (basically, the - * ResultSet MetaData) - * @param tuples Vector of the actual data - * @param status the status string returned from the back end - * @param updateCount the number of rows affected by the operation - * @param cursor the positioned update/delete cursor name - */ - public ResultSet(Connection conn, Field[] fields, Vector tuples, String status, int updateCount) - { - super(conn,fields,tuples,status,updateCount); - } - - /** - * A ResultSet is initially positioned before its first row, - * the first call to next makes the first row the current row; - * the second call makes the second row the current row, etc. - * - *

If an input stream from the previous row is open, it is - * implicitly closed. The ResultSet's warning chain is cleared - * when a new row is read - * - * @return true if the new current is valid; false if there are no - * more rows - * @exception SQLException if a database access error occurs - */ - public boolean next() throws SQLException - { - if (++current_row >= rows.size()) - return false; - this_row = (byte [][])rows.elementAt(current_row); - return true; - } - - /** - * In some cases, it is desirable to immediately release a ResultSet - * database and JDBC resources instead of waiting for this to happen - * when it is automatically closed. The close method provides this - * immediate release. - * - *

Note: A ResultSet is automatically closed by the Statement - * the Statement that generated it when that Statement is closed, - * re-executed, or is used to retrieve the next result from a sequence - * of multiple results. A ResultSet is also automatically closed - * when it is garbage collected. - * - * @exception SQLException if a database access error occurs - */ - public void close() throws SQLException - { - // No-op - } - - /** - * A column may have the value of SQL NULL; wasNull() reports whether - * the last column read had this special value. Note that you must - * first call getXXX on a column to try to read its value and then - * call wasNull() to find if the value was SQL NULL - * - * @return true if the last column read was SQL NULL - * @exception SQLException if a database access error occurred - */ - public boolean wasNull() throws SQLException - { - return wasNullFlag; - } - - /** - * Get the value of a column in the current row as a Java String - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value, null for SQL NULL - * @exception SQLException if a database access error occurs - */ - public String getString(int columnIndex) throws SQLException - { - //byte[] bytes = getBytes(columnIndex); - // - //if (bytes == null) - //return null; - //return new String(bytes); - if (columnIndex < 1 || columnIndex > fields.length) - throw new PSQLException("postgresql.res.colrange"); - wasNullFlag = (this_row[columnIndex - 1] == null); - if(wasNullFlag) - return null; - return new String(this_row[columnIndex - 1]); - } - - /** - * Get the value of a column in the current row as a Java boolean - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value, false for SQL NULL - * @exception SQLException if a database access error occurs - */ - public boolean getBoolean(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - int c = s.charAt(0); - return ((c == 't') || (c == 'T')); - } - return false; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java byte. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public byte getByte(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Byte.parseByte(s); - } catch (NumberFormatException e) { - throw new PSQLException("postgresql.res.badbyte",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java short. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public short getShort(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Short.parseShort(s); - } catch (NumberFormatException e) { - throw new PSQLException("postgresql.res.badshort",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java int. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public int getInt(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Integer.parseInt(s); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.badint",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java long. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public long getLong(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Long.parseLong(s); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.badlong",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java float. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public float getFloat(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Float.valueOf(s).floatValue(); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.badfloat",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java double. - * - * @param columnIndex the first column is 1, the second is 2,... - * @return the column value; 0 if SQL NULL - * @exception SQLException if a database access error occurs - */ - public double getDouble(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - return Double.valueOf(s).doubleValue(); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.baddouble",s); - } - } - return 0; // SQL NULL - } - - /** - * Get the value of a column in the current row as a - * java.math.BigDecimal object - * - * @param columnIndex the first column is 1, the second is 2... - * @param scale the number of digits to the right of the decimal - * @return the column value; if the value is SQL NULL, null - * @exception SQLException if a database access error occurs - * @deprecated - */ - public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException - { - String s = getString(columnIndex); - BigDecimal val; - - if (s != null) - { - try - { - val = new BigDecimal(s); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.badbigdec",s); - } - try - { - return val.setScale(scale); - } catch (ArithmeticException e) { - throw new PSQLException ("postgresql.res.badbigdec",s); - } - } - return null; // SQL NULL - } - - /** - * Get the value of a column in the current row as a Java byte array. - * - *

In normal use, the bytes represent the raw values returned by the - * backend. However, if the column is an OID, then it is assumed to - * refer to a Large Object, and that object is returned as a byte array. - * - *

Be warned If the large object is huge, then you may run out - * of memory. - * - * @param columnIndex the first column is 1, the second is 2, ... - * @return the column value; if the value is SQL NULL, the result - * is null - * @exception SQLException if a database access error occurs - */ - public byte[] getBytes(int columnIndex) throws SQLException - { - if (columnIndex < 1 || columnIndex > fields.length) - throw new PSQLException("postgresql.res.colrange"); - wasNullFlag = (this_row[columnIndex - 1] == null); - - // Handle OID's as BLOBS - if(!wasNullFlag) - if( fields[columnIndex - 1].getOID() == 26) { - LargeObjectManager lom = connection.getLargeObjectAPI(); - LargeObject lob = lom.open(getInt(columnIndex)); - byte buf[] = lob.read(lob.size()); - lob.close(); - return buf; - } - - return this_row[columnIndex - 1]; - } - - /** - * Get the value of a column in the current row as a java.sql.Date - * object - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value; null if SQL NULL - * @exception SQLException if a database access error occurs - */ - public java.sql.Date getDate(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - if(s==null) - return null; - SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); - try { - return new java.sql.Date(df.parse(s).getTime()); - } catch (ParseException e) { - throw new PSQLException("postgresql.res.baddate",new Integer(e.getErrorOffset()),s); - } - } - - /** - * Get the value of a column in the current row as a java.sql.Time - * object - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value; null if SQL NULL - * @exception SQLException if a database access error occurs - */ - public Time getTime(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - - if (s != null) - { - try - { - if (s.length() != 5 && s.length() != 8) - throw new NumberFormatException("Wrong Length!"); - int hr = Integer.parseInt(s.substring(0,2)); - int min = Integer.parseInt(s.substring(3,5)); - int sec = (s.length() == 5) ? 0 : Integer.parseInt(s.substring(6)); - return new Time(hr, min, sec); - } catch (NumberFormatException e) { - throw new PSQLException ("postgresql.res.badtime",s); - } - } - return null; // SQL NULL - } - - /** - * Get the value of a column in the current row as a - * java.sql.Timestamp object - * - * @param columnIndex the first column is 1, the second is 2... - * @return the column value; null if SQL NULL - * @exception SQLException if a database access error occurs - */ - public Timestamp getTimestamp(int columnIndex) throws SQLException - { - String s = getString(columnIndex); - if(s==null) - return null; - - SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:sszzz"); - - try { - return new Timestamp(df.parse(s).getTime()); - } catch(ParseException e) { - throw new PSQLException("postgresql.res.badtimestamp",new Integer(e.getErrorOffset()),s); - } - } - - /** - * A column value can be retrieved as a stream of ASCII characters - * and then read in chunks from the stream. This method is - * particular suitable for retrieving large LONGVARCHAR values. - * The JDBC driver will do any necessary conversion from the - * database format into ASCII. - * - *

Note: All the data in the returned stream must be read - * prior to getting the value of any other column. The next call - * to a get method implicitly closes the stream. Also, a stream - * may return 0 for available() whether there is data available - * or not. - * - *

We implement an ASCII stream as a Binary stream - we should really - * do the data conversion, but I cannot be bothered to implement this - * right now. - * - * @param columnIndex the first column is 1, the second is 2, ... - * @return a Java InputStream that delivers the database column - * value as a stream of one byte ASCII characters. If the - * value is SQL NULL then the result is null - * @exception SQLException if a database access error occurs - * @see getBinaryStream - */ - public InputStream getAsciiStream(int columnIndex) throws SQLException - { - return getBinaryStream(columnIndex); - } - - /** - * A column value can also be retrieved as a stream of Unicode - * characters. We implement this as a binary stream. - * - * ** DEPRECATED IN JDBC 2 ** - * - * @param columnIndex the first column is 1, the second is 2... - * @return a Java InputStream that delivers the database column value - * as a stream of two byte Unicode characters. If the value is - * SQL NULL, then the result is null - * @exception SQLException if a database access error occurs - * @see getAsciiStream - * @see getBinaryStream - * @deprecated - */ - public InputStream getUnicodeStream(int columnIndex) throws SQLException - { - return getBinaryStream(columnIndex); - } - - /** - * A column value can also be retrieved as a binary strea. This - * method is suitable for retrieving LONGVARBINARY values. - * - * @param columnIndex the first column is 1, the second is 2... - * @return a Java InputStream that delivers the database column value - * as a stream of bytes. If the value is SQL NULL, then the result - * is null - * @exception SQLException if a database access error occurs - * @see getAsciiStream - * @see getUnicodeStream - */ - public InputStream getBinaryStream(int columnIndex) throws SQLException - { - byte b[] = getBytes(columnIndex); - - if (b != null) - return new ByteArrayInputStream(b); - return null; // SQL NULL - } - - /** - * The following routines simply convert the columnName into - * a columnIndex and then call the appropriate routine above. - * - * @param columnName is the SQL name of the column - * @return the column value - * @exception SQLException if a database access error occurs - */ - public String getString(String columnName) throws SQLException - { - return getString(findColumn(columnName)); - } - - public boolean getBoolean(String columnName) throws SQLException - { - return getBoolean(findColumn(columnName)); - } - - public byte getByte(String columnName) throws SQLException - { - - return getByte(findColumn(columnName)); - } - - public short getShort(String columnName) throws SQLException - { - return getShort(findColumn(columnName)); - } - - public int getInt(String columnName) throws SQLException - { - return getInt(findColumn(columnName)); - } - - public long getLong(String columnName) throws SQLException - { - return getLong(findColumn(columnName)); - } - - public float getFloat(String columnName) throws SQLException - { - return getFloat(findColumn(columnName)); - } - - public double getDouble(String columnName) throws SQLException - { - return getDouble(findColumn(columnName)); - } - - /** - * @deprecated - */ - public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException - { - return getBigDecimal(findColumn(columnName), scale); - } - - public byte[] getBytes(String columnName) throws SQLException - { - return getBytes(findColumn(columnName)); - } - - public java.sql.Date getDate(String columnName) throws SQLException - { - return getDate(findColumn(columnName)); - } - - public Time getTime(String columnName) throws SQLException - { - return getTime(findColumn(columnName)); - } - - public Timestamp getTimestamp(String columnName) throws SQLException - { - return getTimestamp(findColumn(columnName)); - } - - public InputStream getAsciiStream(String columnName) throws SQLException - { - return getAsciiStream(findColumn(columnName)); - } - - /** - * - * ** DEPRECATED IN JDBC 2 ** - * - * @deprecated - */ - public InputStream getUnicodeStream(String columnName) throws SQLException - { - return getUnicodeStream(findColumn(columnName)); - } - - public InputStream getBinaryStream(String columnName) throws SQLException - { - return getBinaryStream(findColumn(columnName)); - } - - /** - * The first warning reported by calls on this ResultSet is - * returned. Subsequent ResultSet warnings will be chained - * to this SQLWarning. - * - *

The warning chain is automatically cleared each time a new - * row is read. - * - *

Note: This warning chain only covers warnings caused by - * ResultSet methods. Any warnings caused by statement methods - * (such as reading OUT parameters) will be chained on the - * Statement object. - * - * @return the first SQLWarning or null; - * @exception SQLException if a database access error occurs. - */ - public SQLWarning getWarnings() throws SQLException - { - return warnings; - } - - /** - * After this call, getWarnings returns null until a new warning - * is reported for this ResultSet - * - * @exception SQLException if a database access error occurs - */ - public void clearWarnings() throws SQLException - { - warnings = null; - } - - /** - * Get the name of the SQL cursor used by this ResultSet - * - *

In SQL, a result table is retrieved though a cursor that is - * named. The current row of a result can be updated or deleted - * using a positioned update/delete statement that references - * the cursor name. - * - *

JDBC supports this SQL feature by providing the name of the - * SQL cursor used by a ResultSet. The current row of a ResulSet - * is also the current row of this SQL cursor. - * - *

Note: If positioned update is not supported, a SQLException - * is thrown. - * - * @return the ResultSet's SQL cursor name. - * @exception SQLException if a database access error occurs - */ - public String getCursorName() throws SQLException - { - return connection.getCursorName(); - } - - /** - * The numbers, types and properties of a ResultSet's columns are - * provided by the getMetaData method - * - * @return a description of the ResultSet's columns - * @exception SQLException if a database access error occurs - */ - public java.sql.ResultSetMetaData getMetaData() throws SQLException - { - return new ResultSetMetaData(rows, fields); - } - - /** - * Get the value of a column in the current row as a Java object - * - *

This method will return the value of the given column as a - * Java object. The type of the Java object will be the default - * Java Object type corresponding to the column's SQL type, following - * the mapping specified in the JDBC specification. - * - *

This method may also be used to read database specific abstract - * data types. - * - * @param columnIndex the first column is 1, the second is 2... - * @return a Object holding the column value - * @exception SQLException if a database access error occurs - */ - public Object getObject(int columnIndex) throws SQLException - { - Field field; - - if (columnIndex < 1 || columnIndex > fields.length) - throw new PSQLException("postgresql.res.colrange"); - field = fields[columnIndex - 1]; - - // some fields can be null, mainly from those returned by MetaData methods - if(field==null) { - wasNullFlag=true; - return null; - } - - switch (field.getSQLType()) - { - case Types.BIT: - return new Boolean(getBoolean(columnIndex)); - case Types.SMALLINT: - return new Integer(getInt(columnIndex)); - case Types.INTEGER: - return new Integer(getInt(columnIndex)); - case Types.BIGINT: - return new Long(getLong(columnIndex)); - case Types.NUMERIC: - return getBigDecimal(columnIndex, ((field.mod-4) & 0xffff)); - case Types.REAL: - return new Float(getFloat(columnIndex)); - case Types.DOUBLE: - return new Double(getDouble(columnIndex)); - case Types.CHAR: - case Types.VARCHAR: - return getString(columnIndex); - case Types.DATE: - return getDate(columnIndex); - case Types.TIME: - return getTime(columnIndex); - case Types.TIMESTAMP: - return getTimestamp(columnIndex); - default: - return connection.getObject(field.getTypeName(), getString(columnIndex)); - } - } - - /** - * Get the value of a column in the current row as a Java object - * - *

This method will return the value of the given column as a - * Java object. The type of the Java object will be the default - * Java Object type corresponding to the column's SQL type, following - * the mapping specified in the JDBC specification. - * - *

This method may also be used to read database specific abstract - * data types. - * - * @param columnName is the SQL name of the column - * @return a Object holding the column value - * @exception SQLException if a database access error occurs - */ - public Object getObject(String columnName) throws SQLException - { - return getObject(findColumn(columnName)); - } - - /** - * Map a ResultSet column name to a ResultSet column index - * - * @param columnName the name of the column - * @return the column index - * @exception SQLException if a database access error occurs - */ - public int findColumn(String columnName) throws SQLException - { - int i; - - for (i = 0 ; i < fields.length; ++i) - if (fields[i].name.equalsIgnoreCase(columnName)) - return (i+1); - throw new PSQLException ("postgresql.res.colname",columnName); - } - - // ** JDBC 2 Extensions ** - - public boolean absolute(int index) throws SQLException - { - if (index < 0 || index > rows.size()) - return false; - this_row = (byte [][])rows.elementAt(index); - return true; - } - - public void afterLast() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void beforeFirst() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void cancelRowUpdates() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void deleteRow() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean first() throws SQLException - { - if (rows.size() <= 0) - return false; - current_row = 0; - this_row = (byte [][])rows.elementAt(current_row); - return true; - } - - public Array getArray(String colName) throws SQLException - { - return getArray(findColumn(colName)); - } - - public Array getArray(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.math.BigDecimal getBigDecimal(int columnIndex) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.math.BigDecimal getBigDecimal(String columnName) throws SQLException - { - return getBigDecimal(findColumn(columnName)); - } - - public Blob getBlob(String columnName) throws SQLException - { - return getBlob(findColumn(columnName)); - } - - public Blob getBlob(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.io.Reader getCharacterStream(String columnName) throws SQLException - { - return getCharacterStream(findColumn(columnName)); - } - - public java.io.Reader getCharacterStream(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Clob getClob(String columnName) throws SQLException - { - return getClob(findColumn(columnName)); - } - - public Clob getClob(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public int getConcurrency() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.sql.Date getDate(int i,java.util.Calendar cal) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Time getTime(int i,java.util.Calendar cal) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Timestamp getTimestamp(int i,java.util.Calendar cal) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public java.sql.Date getDate(String c,java.util.Calendar cal) throws SQLException - { - return getDate(findColumn(c),cal); - } - - public Time getTime(String c,java.util.Calendar cal) throws SQLException - { - return getTime(findColumn(c),cal); - } - - public Timestamp getTimestamp(String c,java.util.Calendar cal) throws SQLException - { - return getTimestamp(findColumn(c),cal); - } - - public int getFetchDirection() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public int getFetchSize() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public int getKeysetSize() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Object getObject(String columnName,java.util.Map map) throws SQLException - { - return getObject(findColumn(columnName),map); - } - - public Object getObject(int i,java.util.Map map) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public Ref getRef(String columnName) throws SQLException - { - return getRef(findColumn(columnName)); - } - - public Ref getRef(int i) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public int getRow() throws SQLException - { - return current_row; - } - - // This one needs some thought, as not all ResultSets come from a statement - public java.sql.Statement getStatement() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public int getType() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void insertRow() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean isAfterLast() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean isBeforeFirst() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean isFirst() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean isLast() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean last() throws SQLException - { - if (rows.size() <= 0) - return false; - current_row = rows.size() - 1; - this_row = (byte [][])rows.elementAt(current_row); - return true; - } - - public void moveToCurrentRow() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void moveToInsertRow() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean previous() throws SQLException - { - if (--current_row < 0) - return false; - this_row = (byte [][])rows.elementAt(current_row); - return true; - } - - public void refreshRow() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean relative(int rows) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean rowDeleted() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean rowInserted() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public boolean rowUpdated() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setFetchDirection(int direction) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setFetchSize(int rows) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void setKeysetSize(int keys) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateAsciiStream(int columnIndex, - java.io.InputStream x, - int length - ) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateAsciiStream(String columnName, - java.io.InputStream x, - int length - ) throws SQLException - { - updateAsciiStream(findColumn(columnName),x,length); - } - - public void updateBigDecimal(int columnIndex, - java.math.BigDecimal x - ) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateBigDecimal(String columnName, - java.math.BigDecimal x - ) throws SQLException - { - updateBigDecimal(findColumn(columnName),x); - } - - public void updateBinaryStream(int columnIndex, - java.io.InputStream x, - int length - ) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateBinaryStream(String columnName, - java.io.InputStream x, - int length - ) throws SQLException - { - updateBinaryStream(findColumn(columnName),x,length); - } - - public void updateBoolean(int columnIndex,boolean x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateBoolean(String columnName,boolean x) throws SQLException - { - updateBoolean(findColumn(columnName),x); - } - - public void updateByte(int columnIndex,byte x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateByte(String columnName,byte x) throws SQLException - { - updateByte(findColumn(columnName),x); - } - - public void updateBytes(String columnName,byte[] x) throws SQLException - { - updateBytes(findColumn(columnName),x); - } - - public void updateBytes(int columnIndex,byte[] x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateCharacterStream(int columnIndex, - java.io.Reader x, - int length - ) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateCharacterStream(String columnName, - java.io.Reader x, - int length - ) throws SQLException - { - updateCharacterStream(findColumn(columnName),x,length); - } - - public void updateDate(int columnIndex,java.sql.Date x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateDate(String columnName,java.sql.Date x) throws SQLException - { - updateDate(findColumn(columnName),x); - } - - public void updateDouble(int columnIndex,double x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateDouble(String columnName,double x) throws SQLException - { - updateDouble(findColumn(columnName),x); - } - - public void updateFloat(int columnIndex,float x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateFloat(String columnName,float x) throws SQLException - { - updateFloat(findColumn(columnName),x); - } - - public void updateInt(int columnIndex,int x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateInt(String columnName,int x) throws SQLException - { - updateInt(findColumn(columnName),x); - } - - public void updateLong(int columnIndex,long x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateLong(String columnName,long x) throws SQLException - { - updateLong(findColumn(columnName),x); - } - - public void updateNull(int columnIndex) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateNull(String columnName) throws SQLException - { - updateNull(findColumn(columnName)); - } - - public void updateObject(int columnIndex,Object x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateObject(String columnName,Object x) throws SQLException - { - updateObject(findColumn(columnName),x); - } - - public void updateObject(int columnIndex,Object x,int scale) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateObject(String columnName,Object x,int scale) throws SQLException - { - updateObject(findColumn(columnName),x,scale); - } - - public void updateRow() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateShort(int columnIndex,short x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateShort(String columnName,short x) throws SQLException - { - updateShort(findColumn(columnName),x); - } - - public void updateString(int columnIndex,String x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateString(String columnName,String x) throws SQLException - { - updateString(findColumn(columnName),x); - } - - public void updateTime(int columnIndex,Time x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateTime(String columnName,Time x) throws SQLException - { - updateTime(findColumn(columnName),x); - } - - public void updateTimestamp(int columnIndex,Timestamp x) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - public void updateTimestamp(String columnName,Timestamp x) throws SQLException - { - updateTimestamp(findColumn(columnName),x); - } - -} - diff --git a/src/interfaces/jdbc/postgresql/jdbc2/ResultSetMetaData.java b/src/interfaces/jdbc/postgresql/jdbc2/ResultSetMetaData.java deleted file mode 100644 index 7956dea96f..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc2/ResultSetMetaData.java +++ /dev/null @@ -1,455 +0,0 @@ -package postgresql.jdbc2; - -// IMPORTANT NOTE: This file implements the JDBC 2 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 1 class in the -// postgresql.jdbc1 package. - -import java.lang.*; -import java.sql.*; -import java.util.*; -import postgresql.*; -import postgresql.util.*; - -/** - * A ResultSetMetaData object can be used to find out about the types and - * properties of the columns in a ResultSet - * - * @see java.sql.ResultSetMetaData - */ -public class ResultSetMetaData implements java.sql.ResultSetMetaData -{ - Vector rows; - Field[] fields; - - /** - * Initialise for a result with a tuple set and - * a field descriptor set - * - * @param rows the Vector of rows returned by the ResultSet - * @param fields the array of field descriptors - */ - public ResultSetMetaData(Vector rows, Field[] fields) - { - this.rows = rows; - this.fields = fields; - } - - /** - * Whats the number of columns in the ResultSet? - * - * @return the number - * @exception SQLException if a database access error occurs - */ - public int getColumnCount() throws SQLException - { - return fields.length; - } - - /** - * Is the column automatically numbered (and thus read-only) - * I believe that PostgreSQL does not support this feature. - * - * @param column the first column is 1, the second is 2... - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isAutoIncrement(int column) throws SQLException - { - return false; - } - - /** - * Does a column's case matter? ASSUMPTION: Any field that is - * not obviously case insensitive is assumed to be case sensitive - * - * @param column the first column is 1, the second is 2... - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isCaseSensitive(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - switch (sql_type) - { - case Types.SMALLINT: - case Types.INTEGER: - case Types.FLOAT: - case Types.REAL: - case Types.DOUBLE: - case Types.DATE: - case Types.TIME: - case Types.TIMESTAMP: - return false; - default: - return true; - } - } - - /** - * Can the column be used in a WHERE clause? Basically for - * this, I split the functions into two types: recognised - * types (which are always useable), and OTHER types (which - * may or may not be useable). The OTHER types, for now, I - * will assume they are useable. We should really query the - * catalog to see if they are useable. - * - * @param column the first column is 1, the second is 2... - * @return true if they can be used in a WHERE clause - * @exception SQLException if a database access error occurs - */ - public boolean isSearchable(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - // This switch is pointless, I know - but it is a set-up - // for further expansion. - switch (sql_type) - { - case Types.OTHER: - return true; - default: - return true; - } - } - - /** - * Is the column a cash value? 6.1 introduced the cash/money - * type, which haven't been incorporated as of 970414, so I - * just check the type name for both 'cash' and 'money' - * - * @param column the first column is 1, the second is 2... - * @return true if its a cash column - * @exception SQLException if a database access error occurs - */ - public boolean isCurrency(int column) throws SQLException - { - String type_name = getField(column).getTypeName(); - - return type_name.equals("cash") || type_name.equals("money"); - } - - /** - * Can you put a NULL in this column? I think this is always - * true in 6.1's case. It would only be false if the field had - * been defined NOT NULL (system catalogs could be queried?) - * - * @param column the first column is 1, the second is 2... - * @return one of the columnNullable values - * @exception SQLException if a database access error occurs - */ - public int isNullable(int column) throws SQLException - { - return columnNullable; // We can always put NULL in - } - - /** - * Is the column a signed number? In PostgreSQL, all numbers - * are signed, so this is trivial. However, strings are not - * signed (duh!) - * - * @param column the first column is 1, the second is 2... - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isSigned(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - switch (sql_type) - { - case Types.SMALLINT: - case Types.INTEGER: - case Types.FLOAT: - case Types.REAL: - case Types.DOUBLE: - return true; - case Types.DATE: - case Types.TIME: - case Types.TIMESTAMP: - return false; // I don't know about these? - default: - return false; - } - } - - /** - * What is the column's normal maximum width in characters? - * - * @param column the first column is 1, the second is 2, etc. - * @return the maximum width - * @exception SQLException if a database access error occurs - */ - public int getColumnDisplaySize(int column) throws SQLException - { - Field f = getField(column); - String type_name = f.getTypeName(); - int sql_type = f.getSQLType(); - int typmod = f.mod; - - // I looked at other JDBC implementations and couldn't find a consistent - // interpretation of the "display size" for numeric values, so this is our's - // FIXME: currently, only types with a SQL92 or SQL3 pendant are implemented - jens@jens.de - - // fixed length data types - if (type_name.equals( "int2" )) return 6; // -32768 to +32768 (5 digits and a sign) - if (type_name.equals( "int4" ) - || type_name.equals( "oid" )) return 11; // -2147483648 to +2147483647 - if (type_name.equals( "int8" )) return 20; // -9223372036854775808 to +9223372036854775807 - if (type_name.equals( "money" )) return 12; // MONEY = DECIMAL(9,2) - if (type_name.equals( "float4" )) return 11; // i checked it out ans wasn't able to produce more than 11 digits - if (type_name.equals( "float8" )) return 20; // dito, 20 - if (type_name.equals( "char" )) return 1; - if (type_name.equals( "bool" )) return 1; - if (type_name.equals( "date" )) return 14; // "01/01/4713 BC" - "31/12/32767 AD" - if (type_name.equals( "time" )) return 8; // 00:00:00-23:59:59 - if (type_name.equals( "timestamp" )) return 22; // hhmmm ... the output looks like this: 1999-08-03 22:22:08+02 - - // variable length fields - typmod -= 4; - if (type_name.equals( "bpchar" ) - || type_name.equals( "varchar" )) return typmod; // VARHDRSZ=sizeof(int32)=4 - if (type_name.equals( "numeric" )) return ( (typmod >>16) & 0xffff ) - + 1 + ( typmod & 0xffff ); // DECIMAL(p,s) = (p digits).(s digits) - - // if we don't know better - return f.length; - } - - /** - * What is the suggested column title for use in printouts and - * displays? We suggest the ColumnName! - * - * @param column the first column is 1, the second is 2, etc. - * @return the column label - * @exception SQLException if a database access error occurs - */ - public String getColumnLabel(int column) throws SQLException - { - return getColumnName(column); - } - - /** - * What's a column's name? - * - * @param column the first column is 1, the second is 2, etc. - * @return the column name - * @exception SQLException if a database access error occurs - */ - public String getColumnName(int column) throws SQLException - { - Field f = getField(column); - if(f!=null) - return f.name; - return "field"+column; - } - - /** - * What is a column's table's schema? This relies on us knowing - * the table name....which I don't know how to do as yet. The - * JDBC specification allows us to return "" if this is not - * applicable. - * - * @param column the first column is 1, the second is 2... - * @return the Schema - * @exception SQLException if a database access error occurs - */ - public String getSchemaName(int column) throws SQLException - { - return ""; - } - - /** - * What is a column's number of decimal digits. - * - * @param column the first column is 1, the second is 2... - * @return the precision - * @exception SQLException if a database access error occurs - */ - public int getPrecision(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - switch (sql_type) - { - case Types.SMALLINT: - return 5; - case Types.INTEGER: - return 10; - case Types.REAL: - return 8; - case Types.FLOAT: - return 16; - case Types.DOUBLE: - return 16; - case Types.VARCHAR: - return 0; - default: - return 0; - } - } - - /** - * What is a column's number of digits to the right of the - * decimal point? - * - * @param column the first column is 1, the second is 2... - * @return the scale - * @exception SQLException if a database access error occurs - */ - public int getScale(int column) throws SQLException - { - int sql_type = getField(column).getSQLType(); - - switch (sql_type) - { - case Types.SMALLINT: - return 0; - case Types.INTEGER: - return 0; - case Types.REAL: - return 8; - case Types.FLOAT: - return 16; - case Types.DOUBLE: - return 16; - case Types.VARCHAR: - return 0; - default: - return 0; - } - } - - /** - * Whats a column's table's name? How do I find this out? Both - * getSchemaName() and getCatalogName() rely on knowing the table - * Name, so we need this before we can work on them. - * - * @param column the first column is 1, the second is 2... - * @return column name, or "" if not applicable - * @exception SQLException if a database access error occurs - */ - public String getTableName(int column) throws SQLException - { - return ""; - } - - /** - * What's a column's table's catalog name? As with getSchemaName(), - * we can say that if getTableName() returns n/a, then we can too - - * otherwise, we need to work on it. - * - * @param column the first column is 1, the second is 2... - * @return catalog name, or "" if not applicable - * @exception SQLException if a database access error occurs - */ - public String getCatalogName(int column) throws SQLException - { - return ""; - } - - /** - * What is a column's SQL Type? (java.sql.Type int) - * - * @param column the first column is 1, the second is 2, etc. - * @return the java.sql.Type value - * @exception SQLException if a database access error occurs - * @see postgresql.Field#getSQLType - * @see java.sql.Types - */ - public int getColumnType(int column) throws SQLException - { - return getField(column).getSQLType(); - } - - /** - * Whats is the column's data source specific type name? - * - * @param column the first column is 1, the second is 2, etc. - * @return the type name - * @exception SQLException if a database access error occurs - */ - public String getColumnTypeName(int column) throws SQLException - { - return getField(column).getTypeName(); - } - - /** - * Is the column definitely not writable? In reality, we would - * have to check the GRANT/REVOKE stuff for this to be effective, - * and I haven't really looked into that yet, so this will get - * re-visited. - * - * @param column the first column is 1, the second is 2, etc. - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isReadOnly(int column) throws SQLException - { - return false; - } - - /** - * Is it possible for a write on the column to succeed? Again, we - * would in reality have to check the GRANT/REVOKE stuff, which - * I haven't worked with as yet. However, if it isn't ReadOnly, then - * it is obviously writable. - * - * @param column the first column is 1, the second is 2, etc. - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isWritable(int column) throws SQLException - { - if (isReadOnly(column)) - return true; - else - return false; - } - - /** - * Will a write on this column definately succeed? Hmmm...this - * is a bad one, since the two preceding functions have not been - * really defined. I cannot tell is the short answer. I thus - * return isWritable() just to give us an idea. - * - * @param column the first column is 1, the second is 2, etc.. - * @return true if so - * @exception SQLException if a database access error occurs - */ - public boolean isDefinitelyWritable(int column) throws SQLException - { - return isWritable(column); - } - - // ******************************************************** - // END OF PUBLIC INTERFACE - // ******************************************************** - - /** - * For several routines in this package, we need to convert - * a columnIndex into a Field[] descriptor. Rather than do - * the same code several times, here it is. - * - * @param columnIndex the first column is 1, the second is 2... - * @return the Field description - * @exception SQLException if a database access error occurs - */ - private Field getField(int columnIndex) throws SQLException - { - if (columnIndex < 1 || columnIndex > fields.length) - throw new PSQLException("postgresql.res.colrange"); - return fields[columnIndex - 1]; - } - - // ** JDBC 2 Extensions ** - - // This can hook into our PG_Object mechanism - public String getColumnClassName(int column) throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - -} - diff --git a/src/interfaces/jdbc/postgresql/jdbc2/Statement.java b/src/interfaces/jdbc/postgresql/jdbc2/Statement.java deleted file mode 100644 index 26011ba765..0000000000 --- a/src/interfaces/jdbc/postgresql/jdbc2/Statement.java +++ /dev/null @@ -1,418 +0,0 @@ -package postgresql.jdbc2; - -// IMPORTANT NOTE: This file implements the JDBC 2 version of the driver. -// If you make any modifications to this file, you must make sure that the -// changes are also made (if relevent) to the related JDBC 1 class in the -// postgresql.jdbc1 package. - -import java.sql.*; -import java.util.Vector; -import postgresql.util.*; - -/** - * A Statement object is used for executing a static SQL statement and - * obtaining the results produced by it. - * - *

Only one ResultSet per Statement can be open at any point in time. - * Therefore, if the reading of one ResultSet is interleaved with the - * reading of another, each must have been generated by different - * Statements. All statement execute methods implicitly close a - * statement's current ResultSet if an open one exists. - * - * @see java.sql.Statement - * @see ResultSet - */ -public class Statement implements java.sql.Statement -{ - Connection connection; // The connection who created us - java.sql.ResultSet result = null; // The current results - SQLWarning warnings = null; // The warnings chain. - int timeout = 0; // The timeout for a query (not used) - boolean escapeProcessing = true;// escape processing flag - private Vector batch=null; - - /** - * Constructor for a Statement. It simply sets the connection - * that created us. - * - * @param c the Connection instantation that creates us - */ - public Statement (Connection c) - { - connection = c; - } - - /** - * Execute a SQL statement that retruns a single ResultSet - * - * @param sql typically a static SQL SELECT statement - * @return a ResulSet that contains the data produced by the query - * @exception SQLException if a database access error occurs - */ - public java.sql.ResultSet executeQuery(String sql) throws SQLException - { - this.execute(sql); - while (result != null && !((postgresql.ResultSet)result).reallyResultSet()) - result = ((postgresql.ResultSet)result).getNext(); - if (result == null) - throw new PSQLException("postgresql.stat.noresult"); - return result; - } - - /** - * Execute a SQL INSERT, UPDATE or DELETE statement. In addition - * SQL statements that return nothing such as SQL DDL statements - * can be executed - * - * @param sql a SQL statement - * @return either a row count, or 0 for SQL commands - * @exception SQLException if a database access error occurs - */ - public int executeUpdate(String sql) throws SQLException - { - this.execute(sql); - if (((postgresql.ResultSet)result).reallyResultSet()) - throw new PSQLException("postgresql.stat.result"); - return this.getUpdateCount(); - } - - /** - * In many cases, it is desirable to immediately release a - * Statement's database and JDBC resources instead of waiting - * for this to happen when it is automatically closed. The - * close method provides this immediate release. - * - *

Note: A Statement is automatically closed when it is - * garbage collected. When a Statement is closed, its current - * ResultSet, if one exists, is also closed. - * - * @exception SQLException if a database access error occurs (why?) - */ - public void close() throws SQLException - { - result = null; - } - - /** - * The maxFieldSize limit (in bytes) is the maximum amount of - * data returned for any column value; it only applies to - * BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR and LONGVARCHAR - * columns. If the limit is exceeded, the excess data is silently - * discarded. - * - * @return the current max column size limit; zero means unlimited - * @exception SQLException if a database access error occurs - */ - public int getMaxFieldSize() throws SQLException - { - return 8192; // We cannot change this - } - - /** - * Sets the maxFieldSize - NOT! - We throw an SQLException just - * to inform them to stop doing this. - * - * @param max the new max column size limit; zero means unlimited - * @exception SQLException if a database access error occurs - */ - public void setMaxFieldSize(int max) throws SQLException - { - throw new PSQLException("postgresql.stat.maxfieldsize"); - } - - /** - * The maxRows limit is set to limit the number of rows that - * any ResultSet can contain. If the limit is exceeded, the - * excess rows are silently dropped. - * - * @return the current maximum row limit; zero means unlimited - * @exception SQLException if a database access error occurs - */ - public int getMaxRows() throws SQLException - { - return connection.maxrows; - } - - /** - * Set the maximum number of rows - * - * @param max the new max rows limit; zero means unlimited - * @exception SQLException if a database access error occurs - * @see getMaxRows - */ - public void setMaxRows(int max) throws SQLException - { - connection.maxrows = max; - } - - /** - * If escape scanning is on (the default), the driver will do escape - * substitution before sending the SQL to the database. - * - * @param enable true to enable; false to disable - * @exception SQLException if a database access error occurs - */ - public void setEscapeProcessing(boolean enable) throws SQLException - { - escapeProcessing = enable; - } - - /** - * The queryTimeout limit is the number of seconds the driver - * will wait for a Statement to execute. If the limit is - * exceeded, a SQLException is thrown. - * - * @return the current query timeout limit in seconds; 0 = unlimited - * @exception SQLException if a database access error occurs - */ - public int getQueryTimeout() throws SQLException - { - return timeout; - } - - /** - * Sets the queryTimeout limit - * - * @param seconds - the new query timeout limit in seconds - * @exception SQLException if a database access error occurs - */ - public void setQueryTimeout(int seconds) throws SQLException - { - timeout = seconds; - } - - /** - * Cancel can be used by one thread to cancel a statement that - * is being executed by another thread. However, PostgreSQL is - * a sync. sort of thing, so this really has no meaning - we - * define it as a no-op (i.e. you can't cancel, but there is no - * error if you try.) - * - * 6.4 introduced a cancel operation, but we have not implemented it - * yet. Sometime before 6.5, this method will be implemented. - * - * @exception SQLException only because thats the spec. - */ - public void cancel() throws SQLException - { - // No-op - } - - /** - * The first warning reported by calls on this Statement is - * returned. A Statement's execute methods clear its SQLWarning - * chain. Subsequent Statement warnings will be chained to this - * SQLWarning. - * - *

The Warning chain is automatically cleared each time a statement - * is (re)executed. - * - *

Note: If you are processing a ResultSet then any warnings - * associated with ResultSet reads will be chained on the ResultSet - * object. - * - * @return the first SQLWarning on null - * @exception SQLException if a database access error occurs - */ - public SQLWarning getWarnings() throws SQLException - { - return warnings; - } - - /** - * After this call, getWarnings returns null until a new warning - * is reported for this Statement. - * - * @exception SQLException if a database access error occurs (why?) - */ - public void clearWarnings() throws SQLException - { - warnings = null; - } - - /** - * setCursorName defines the SQL cursor name that will be used by - * subsequent execute methods. This name can then be used in SQL - * positioned update/delete statements to identify the current row - * in the ResultSet generated by this statement. If a database - * doesn't support positioned update/delete, this method is a - * no-op. - * - *

Note: By definition, positioned update/delete execution - * must be done by a different Statement than the one which - * generated the ResultSet being used for positioning. Also, cursor - * names must be unique within a Connection. - * - *

We throw an additional constriction. There can only be one - * cursor active at any one time. - * - * @param name the new cursor name - * @exception SQLException if a database access error occurs - */ - public void setCursorName(String name) throws SQLException - { - connection.setCursorName(name); - } - - /** - * Execute a SQL statement that may return multiple results. We - * don't have to worry about this since we do not support multiple - * ResultSets. You can use getResultSet or getUpdateCount to - * retrieve the result. - * - * @param sql any SQL statement - * @return true if the next result is a ResulSet, false if it is - * an update count or there are no more results - * @exception SQLException if a database access error occurs - */ - public boolean execute(String sql) throws SQLException - { - result = connection.ExecSQL(sql); - return (result != null && ((postgresql.ResultSet)result).reallyResultSet()); - } - - /** - * getResultSet returns the current result as a ResultSet. It - * should only be called once per result. - * - * @return the current result set; null if there are no more - * @exception SQLException if a database access error occurs (why?) - */ - public java.sql.ResultSet getResultSet() throws SQLException - { - return result; - } - - /** - * getUpdateCount returns the current result as an update count, - * if the result is a ResultSet or there are no more results, -1 - * is returned. It should only be called once per result. - * - * @return the current result as an update count. - * @exception SQLException if a database access error occurs - */ - public int getUpdateCount() throws SQLException - { - if (result == null) return -1; - if (((postgresql.ResultSet)result).reallyResultSet()) return -1; - return ((postgresql.ResultSet)result).getResultCount(); - } - - /** - * getMoreResults moves to a Statement's next result. If it returns - * true, this result is a ResulSet. - * - * @return true if the next ResultSet is valid - * @exception SQLException if a database access error occurs - */ - public boolean getMoreResults() throws SQLException - { - result = ((postgresql.ResultSet)result).getNext(); - return (result != null && ((postgresql.ResultSet)result).reallyResultSet()); - } - - /** - * Returns the status message from the current Result.

- * This is used internally by the driver. - * - * @return status message from backend - */ - public String getResultStatusString() - { - if(result == null) - return null; - return ((postgresql.ResultSet)result).getStatusString(); - } - - // ** JDBC 2 Extensions ** - - public void addBatch(String sql) throws SQLException - { - if(batch==null) - batch=new Vector(); - batch.addElement(sql); - } - - public void clearBatch() throws SQLException - { - if(batch!=null) - batch.removeAllElements(); - } - - public int[] executeBatch() throws SQLException - { - if(batch==null || batch.isEmpty()) - throw new PSQLException("postgresql.stat.batch.empty"); - - int size=batch.size(); - int[] result=new int[size]; - int i=0; - this.execute("begin"); // PTM: check this when autoCommit is false - try { - for(i=0;iIt provides the basic methods required to run the interface, plus - * a pair of methods that provide InputStream and OutputStream classes - * for this object. - * - *

Normally, client code would use the getAsciiStream, getBinaryStream, - * or getUnicodeStream methods in ResultSet, or setAsciiStream, - * setBinaryStream, or setUnicodeStream methods in PreparedStatement to - * access Large Objects. - * - *

However, sometimes lower level access to Large Objects are required, - * that are not supported by the JDBC specification. - * - *

Refer to postgresql.largeobject.LargeObjectManager on how to gain access - * to a Large Object, or how to create one. - * - * @see postgresql.largeobject.LargeObjectManager - * @see postgresql.ResultSet#getAsciiStream - * @see postgresql.ResultSet#getBinaryStream - * @see postgresql.ResultSet#getUnicodeStream - * @see postgresql.PreparedStatement#setAsciiStream - * @see postgresql.PreparedStatement#setBinaryStream - * @see postgresql.PreparedStatement#setUnicodeStream - * @see java.sql.ResultSet#getAsciiStream - * @see java.sql.ResultSet#getBinaryStream - * @see java.sql.ResultSet#getUnicodeStream - * @see java.sql.PreparedStatement#setAsciiStream - * @see java.sql.PreparedStatement#setBinaryStream - * @see java.sql.PreparedStatement#setUnicodeStream - * - */ -public class LargeObject -{ - /** - * Indicates a seek from the begining of a file - */ - public static final int SEEK_SET = 0; - - /** - * Indicates a seek from the current position - */ - public static final int SEEK_CUR = 1; - - /** - * Indicates a seek from the end of a file - */ - public static final int SEEK_END = 2; - - private Fastpath fp; // Fastpath API to use - private int oid; // OID of this object - private int fd; // the descriptor of the open large object - - /** - * This opens a large object. - * - *

If the object does not exist, then an SQLException is thrown. - * - * @param fp FastPath API for the connection to use - * @param oid of the Large Object to open - * @param mode Mode of opening the large object - * (defined in LargeObjectManager) - * @exception SQLException if a database-access error occurs. - * @see postgresql.largeobject.LargeObjectManager - */ - protected LargeObject(Fastpath fp,int oid,int mode) throws SQLException - { - this.fp = fp; - this.oid = oid; - - FastpathArg args[] = new FastpathArg[2]; - args[0] = new FastpathArg(oid); - args[1] = new FastpathArg(mode); - this.fd = fp.getInteger("lo_open",args); - } - - /** - * @return the OID of this LargeObject - */ - public int getOID() - { - return oid; - } - - /** - * This method closes the object. You must not call methods in this - * object after this is called. - * @exception SQLException if a database-access error occurs. - */ - public void close() throws SQLException - { - FastpathArg args[] = new FastpathArg[1]; - args[0] = new FastpathArg(fd); - fp.fastpath("lo_close",false,args); // true here as we dont care!! - } - - /** - * Reads some data from the object, and return as a byte[] array - * - * @param len number of bytes to read - * @return byte[] array containing data read - * @exception SQLException if a database-access error occurs. - */ - public byte[] read(int len) throws SQLException - { - // This is the original method, where the entire block (len bytes) - // is retrieved in one go. - FastpathArg args[] = new FastpathArg[2]; - args[0] = new FastpathArg(fd); - args[1] = new FastpathArg(len); - return fp.getData("loread",args); - - // This version allows us to break this down into 4k blocks - //if(len<=4048) { - //// handle as before, return the whole block in one go - //FastpathArg args[] = new FastpathArg[2]; - //args[0] = new FastpathArg(fd); - //args[1] = new FastpathArg(len); - //return fp.getData("loread",args); - //} else { - //// return in 4k blocks - //byte[] buf=new byte[len]; - //int off=0; - //while(len>0) { - //int bs=4048; - //len-=bs; - //if(len<0) { - //bs+=len; - //len=0; - //} - //read(buf,off,bs); - //off+=bs; - //} - //return buf; - //} - } - - /** - * Reads some data from the object into an existing array - * - * @param buf destination array - * @param off offset within array - * @param len number of bytes to read - * @exception SQLException if a database-access error occurs. - */ - public void read(byte buf[],int off,int len) throws SQLException - { - System.arraycopy(read(len),0,buf,off,len); - } - - /** - * Writes an array to the object - * - * @param buf array to write - * @exception SQLException if a database-access error occurs. - */ - public void write(byte buf[]) throws SQLException - { - FastpathArg args[] = new FastpathArg[2]; - args[0] = new FastpathArg(fd); - args[1] = new FastpathArg(buf); - fp.fastpath("lowrite",false,args); - } - - /** - * Writes some data from an array to the object - * - * @param buf destination array - * @param off offset within array - * @param len number of bytes to write - * @exception SQLException if a database-access error occurs. - */ - public void write(byte buf[],int off,int len) throws SQLException - { - byte data[] = new byte[len]; - System.arraycopy(buf,off,data,0,len); - write(data); - } - - /** - * Sets the current position within the object. - * - *

This is similar to the fseek() call in the standard C library. It - * allows you to have random access to the large object. - * - * @param pos position within object - * @param ref Either SEEK_SET, SEEK_CUR or SEEK_END - * @exception SQLException if a database-access error occurs. - */ - public void seek(int pos,int ref) throws SQLException - { - FastpathArg args[] = new FastpathArg[3]; - args[0] = new FastpathArg(fd); - args[1] = new FastpathArg(pos); - args[2] = new FastpathArg(ref); - fp.fastpath("lo_lseek",false,args); - } - - /** - * Sets the current position within the object. - * - *

This is similar to the fseek() call in the standard C library. It - * allows you to have random access to the large object. - * - * @param pos position within object from begining - * @exception SQLException if a database-access error occurs. - */ - public void seek(int pos) throws SQLException - { - seek(pos,SEEK_SET); - } - - /** - * @return the current position within the object - * @exception SQLException if a database-access error occurs. - */ - public int tell() throws SQLException - { - FastpathArg args[] = new FastpathArg[1]; - args[0] = new FastpathArg(fd); - return fp.getInteger("lo_tell",args); - } - - /** - * This method is inefficient, as the only way to find out the size of - * the object is to seek to the end, record the current position, then - * return to the original position. - * - *

A better method will be found in the future. - * - * @return the size of the large object - * @exception SQLException if a database-access error occurs. - */ - public int size() throws SQLException - { - int cp = tell(); - seek(0,SEEK_END); - int sz = tell(); - seek(cp,SEEK_SET); - return sz; - } - - /** - * Returns an InputStream from this object. - * - *

This InputStream can then be used in any method that requires an - * InputStream. - * - * @exception SQLException if a database-access error occurs. - */ - public InputStream getInputStream() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } - - /** - * Returns an OutputStream to this object - * - *

This OutputStream can then be used in any method that requires an - * OutputStream. - * - * @exception SQLException if a database-access error occurs. - */ - public OutputStream getOutputStream() throws SQLException - { - throw postgresql.Driver.notImplemented(); - } -} diff --git a/src/interfaces/jdbc/postgresql/largeobject/LargeObjectManager.java b/src/interfaces/jdbc/postgresql/largeobject/LargeObjectManager.java deleted file mode 100644 index d82307281e..0000000000 --- a/src/interfaces/jdbc/postgresql/largeobject/LargeObjectManager.java +++ /dev/null @@ -1,206 +0,0 @@ -package postgresql.largeobject; - -import java.io.*; -import java.lang.*; -import java.net.*; -import java.util.*; -import java.sql.*; - -import postgresql.fastpath.*; -import postgresql.util.*; - -/** - * This class implements the large object interface to postgresql. - * - *

It provides methods that allow client code to create, open and delete - * large objects from the database. When opening an object, an instance of - * postgresql.largeobject.LargeObject is returned, and its methods then allow - * access to the object. - * - *

This class can only be created by postgresql.Connection - * - *

To get access to this class, use the following segment of code: - * 

- * import postgresql.largeobject.*;
- *
- * Connection  conn;
- * LargeObjectManager lobj;
- *
- * ... code that opens a connection ...
- *
- * lobj = ((postgresql.Connection)myconn).getLargeObjectAPI();
- *
- * - *

Normally, client code would use the getAsciiStream, getBinaryStream, - * or getUnicodeStream methods in ResultSet, or setAsciiStream, - * setBinaryStream, or setUnicodeStream methods in PreparedStatement to - * access Large Objects. - * - *

However, sometimes lower level access to Large Objects are required, - * that are not supported by the JDBC specification. - * - *

Refer to postgresql.largeobject.LargeObject on how to manipulate the - * contents of a Large Object. - * - * @see postgresql.largeobject.LargeObject - * @see postgresql.ResultSet#getAsciiStream - * @see postgresql.ResultSet#getBinaryStream - * @see postgresql.ResultSet#getUnicodeStream - * @see postgresql.PreparedStatement#setAsciiStream - * @see postgresql.PreparedStatement#setBinaryStream - * @see postgresql.PreparedStatement#setUnicodeStream - * @see java.sql.ResultSet#getAsciiStream - * @see java.sql.ResultSet#getBinaryStream - * @see java.sql.ResultSet#getUnicodeStream - * @see java.sql.PreparedStatement#setAsciiStream - * @see java.sql.PreparedStatement#setBinaryStream - * @see java.sql.PreparedStatement#setUnicodeStream - */ -public class LargeObjectManager -{ - // the fastpath api for this connection - private Fastpath fp; - - /** - * This mode indicates we want to write to an object - */ - public static final int WRITE = 0x00020000; - - /** - * This mode indicates we want to read an object - */ - public static final int READ = 0x00040000; - - /** - * This mode is the default. It indicates we want read and write access to - * a large object - */ - public static final int READWRITE = READ | WRITE; - - /** - * This prevents us being created by mere mortals - */ - private LargeObjectManager() - { - } - - /** - * Constructs the LargeObject API. - * - *

Important Notice - *
This method should only be called by postgresql.Connection - * - *

There should only be one LargeObjectManager per Connection. The - * postgresql.Connection class keeps track of the various extension API's - * and it's advised you use those to gain access, and not going direct. - */ - public LargeObjectManager(postgresql.Connection conn) throws SQLException - { - // We need Fastpath to do anything - this.fp = conn.getFastpathAPI(); - - // Now get the function oid's for the api - // - // This is an example of Fastpath.addFunctions(); - // - java.sql.ResultSet res = (java.sql.ResultSet)conn.createStatement().executeQuery("select proname, oid from pg_proc" + - " where proname = 'lo_open'" + - " or proname = 'lo_close'" + - " or proname = 'lo_creat'" + - " or proname = 'lo_unlink'" + - " or proname = 'lo_lseek'" + - " or proname = 'lo_tell'" + - " or proname = 'loread'" + - " or proname = 'lowrite'"); - - if(res==null) - throw new PSQLException("postgresql.lo.init"); - - fp.addFunctions(res); - res.close(); - DriverManager.println("Large Object initialised"); - } - - /** - * This opens an existing large object, based on its OID. This method - * assumes that READ and WRITE access is required (the default). - * - * @param oid of large object - * @return LargeObject instance providing access to the object - * @exception SQLException on error - */ - public LargeObject open(int oid) throws SQLException - { - return new LargeObject(fp,oid,READWRITE); - } - - /** - * This opens an existing large object, based on its OID - * - * @param oid of large object - * @param mode mode of open - * @return LargeObject instance providing access to the object - * @exception SQLException on error - */ - public LargeObject open(int oid,int mode) throws SQLException - { - return new LargeObject(fp,oid,mode); - } - - /** - * This creates a large object, returning its OID. - * - *

It defaults to READWRITE for the new object's attributes. - * - * @return oid of new object - * @exception SQLException on error - */ - public int create() throws SQLException - { - FastpathArg args[] = new FastpathArg[1]; - args[0] = new FastpathArg(READWRITE); - return fp.getInteger("lo_creat",args); - } - - /** - * This creates a large object, returning its OID - * - * @param mode a bitmask describing different attributes of the new object - * @return oid of new object - * @exception SQLException on error - */ - public int create(int mode) throws SQLException - { - FastpathArg args[] = new FastpathArg[1]; - args[0] = new FastpathArg(mode); - return fp.getInteger("lo_creat",args); - } - - /** - * This deletes a large object. - * - * @param oid describing object to delete - * @exception SQLException on error - */ - public void delete(int oid) throws SQLException - { - FastpathArg args[] = new FastpathArg[1]; - args[0] = new FastpathArg(oid); - fp.fastpath("lo_unlink",false,args); - } - - /** - * This deletes a large object. - * - *

It is identical to the delete method, and is supplied as the C API uses - * unlink. - * - * @param oid describing object to delete - * @exception SQLException on error - */ - public void unlink(int oid) throws SQLException - { - delete(oid); - } - -} diff --git a/src/interfaces/jdbc/postgresql/util/PGmoney.java b/src/interfaces/jdbc/postgresql/util/PGmoney.java deleted file mode 100644 index 0d094dbf10..0000000000 --- a/src/interfaces/jdbc/postgresql/util/PGmoney.java +++ /dev/null @@ -1,105 +0,0 @@ -package postgresql.util; - -import java.io.*; -import java.sql.*; - -/** - * This implements a class that handles the PostgreSQL money and cash types - */ -public class PGmoney extends PGobject implements Serializable,Cloneable -{ - /** - * The value of the field - */ - public double val; - - /** - * @param value of field - */ - public PGmoney(double value) { - this(); - val = value; - } - - /** - * This is called mainly from the other geometric types, when a - * point is imbeded within their definition. - * - * @param value Definition of this point in PostgreSQL's syntax - */ - public PGmoney(String value) throws SQLException - { - this(); - setValue(value); - } - - /** - * Required by the driver - */ - public PGmoney() - { - setType("money"); - } - - /** - * @param s Definition of this point in PostgreSQL's syntax - * @exception SQLException on conversion failure - */ - public void setValue(String s) throws SQLException - { - try { - String s1; - boolean negative; - - negative = (s.charAt(0) == '-') ; - - s1 = s.substring(negative ? 2 : 1); - - int pos = s1.indexOf(','); - while (pos != -1) { - s1 = s1.substring(0,pos) + s1.substring(pos +1); - pos = s1.indexOf(','); - } - - val = Double.valueOf(s1).doubleValue(); - val = negative ? -val : val; - - } catch(NumberFormatException e) { - throw new PSQLException("postgresql.money",e); - } - } - - /** - * @param obj Object to compare with - * @return true if the two boxes are identical - */ - public boolean equals(Object obj) - { - if(obj instanceof PGmoney) { - PGmoney p = (PGmoney)obj; - return val == p.val; - } - return false; - } - - /** - * This must be overidden to allow the object to be cloned - */ - public Object clone() - { - return new PGmoney(val); - } - - /** - * @return the PGpoint in the syntax expected by postgresql - */ - public String getValue() - { - if (val < 0) { - return "-$" + (-val); - } - else { - return "$"+val; - } - } -} diff --git a/src/interfaces/jdbc/postgresql/util/PGobject.java b/src/interfaces/jdbc/postgresql/util/PGobject.java deleted file mode 100644 index 40e4daf435..0000000000 --- a/src/interfaces/jdbc/postgresql/util/PGobject.java +++ /dev/null @@ -1,102 +0,0 @@ -package postgresql.util; - -import java.io.*; -import java.lang.*; -import java.sql.*; -import java.util.*; - -/** - * postgresql.PG_Object is a class used to describe unknown types - * An unknown type is any type that is unknown by JDBC Standards - * - *

As of PostgreSQL 6.3, this allows user code to add their own - * handlers via a call to postgresql.Connection. These handlers - * must extend this class. - */ -public class PGobject implements Serializable,Cloneable -{ - protected String type; - protected String value; - - /** - * This is called by postgresql.Connection.getObject() to create the - * object. - */ - public PGobject() - { - } - - /** - * This method sets the type of this object. - * - *

It should not be extended by subclasses, hence its final - * - * @param type a string describing the type of the object - */ - public final void setType(String type) - { - this.type = type; - } - - /** - * This method sets the value of this object. It must be overidden. - * - * @param value a string representation of the value of the object - * @exception SQLException thrown if value is invalid for this type - */ - public void setValue(String value) throws SQLException - { - this.value = value; - } - - /** - * As this cannot change during the life of the object, it's final. - * @return the type name of this object - */ - public final String getType() - { - return type; - } - - /** - * This must be overidden, to return the value of the object, in the - * form required by postgresql. - * @return the value of this object - */ - public String getValue() - { - return value; - } - - /** - * This must be overidden to allow comparisons of objects - * @param obj Object to compare with - * @return true if the two boxes are identical - */ - public boolean equals(Object obj) - { - if(obj instanceof PGobject) - return ((PGobject)obj).getValue().equals(getValue()); - return false; - } - - /** - * This must be overidden to allow the object to be cloned - */ - public Object clone() - { - PGobject obj = new PGobject(); - obj.type=type; - obj.value=value; - return obj; - } - - /** - * This is defined here, so user code need not overide it. - * @return the value of this object, in the syntax expected by postgresql - */ - public String toString() - { - return getValue(); - } -} diff --git a/src/interfaces/jdbc/postgresql/util/PGtokenizer.java b/src/interfaces/jdbc/postgresql/util/PGtokenizer.java deleted file mode 100644 index 0d07596891..0000000000 --- a/src/interfaces/jdbc/postgresql/util/PGtokenizer.java +++ /dev/null @@ -1,197 +0,0 @@ -package postgresql.util; - -import java.sql.*; -import java.util.*; - -/** - * This class is used to tokenize the text output of postgres. - * - *

It's mainly used by the geometric classes, but is useful in parsing any - * output from custom data types output from postgresql. - * - * @see postgresql.geometric.PGbox - * @see postgresql.geometric.PGcircle - * @see postgresql.geometric.PGlseg - * @see postgresql.geometric.PGpath - * @see postgresql.geometric.PGpoint - * @see postgresql.geometric.PGpolygon - */ -public class PGtokenizer -{ - // Our tokens - protected Vector tokens; - - /** - * Create a tokeniser. - * - *

We could have used StringTokenizer to do this, however, we needed to - * handle nesting of '(' ')' '[' ']' '<' and '>' as these are used - * by the geometric data types. - * - * @param string containing tokens - * @param delim single character to split the tokens - */ - public PGtokenizer(String string,char delim) - { - tokenize(string,delim); - } - - /** - * This resets this tokenizer with a new string and/or delimiter. - * - * @param string containing tokens - * @param delim single character to split the tokens - */ - public int tokenize(String string,char delim) - { - tokens = new Vector(); - - // nest holds how many levels we are in the current token. - // if this is > 0 then we don't split a token when delim is matched. - // - // The Geometric datatypes use this, because often a type may have others - // (usualls PGpoint) imbedded within a token. - // - // Peter 1998 Jan 6 - Added < and > to the nesting rules - int nest=0,p,s; - - for(p=0,s=0;p') - nest--; - - if(nest==0 && c==delim) { - tokens.addElement(string.substring(s,p)); - s=p+1; // +1 to skip the delimiter - } - - } - - // Don't forget the last token ;-) - if(s"); - } - - /** - * Removes < and > from the beginning and end of all tokens - * @return String without the < or > - */ - public void removeAngle() - { - remove("<",">"); - } -} diff --git a/src/interfaces/jdbc/postgresql/util/PSQLException.java b/src/interfaces/jdbc/postgresql/util/PSQLException.java deleted file mode 100644 index 317176a341..0000000000 --- a/src/interfaces/jdbc/postgresql/util/PSQLException.java +++ /dev/null @@ -1,111 +0,0 @@ -package postgresql.util; - -import java.sql.*; -import java.text.*; -import java.util.*; - -/** - * This class extends SQLException, and provides our internationalisation handling - */ -public class PSQLException extends SQLException -{ - private String message; - - // Cache for future errors - static ResourceBundle bundle; - - /** - * This provides the same functionality to SQLException - * @param error Error string - */ - public PSQLException(String error) { - super(); - translate(error,null); - } - - /** - * A more generic entry point. - * @param error Error string or standard message id - * @param args Array of arguments - */ - public PSQLException(String error,Object[] args) - { - super(); - translate(error,args); - } - - /** - * Helper version for 1 arg - */ - public PSQLException(String error,Object arg) - { - super(); - Object[] argv = new Object[1]; - argv[0] = arg; - translate(error,argv); - } - - /** - * Helper version for 2 args - */ - public PSQLException(String error,Object arg1,Object arg2) - { - super(); - Object[] argv = new Object[2]; - argv[0] = arg1; - argv[1] = arg2; - translate(error,argv); - } - - /** - * This does the actual translation - */ - private void translate(String id,Object[] args) - { - if(bundle == null) { - try { - bundle = ResourceBundle.getBundle("postgresql.errors"); - } catch(MissingResourceException e) { - } - } - - // Now look up a localized message. If one is not found, then use - // the supplied message instead. - message = null; - try { - message = bundle.getString(id); - } catch(MissingResourceException e) { - message = id; - } - - // Expand any arguments - if(args!=null) - message = MessageFormat.format(message,args); - - } - - /** - * Overides Throwable - */ - public String getLocalizedMessage() - { - return message; - } - - /** - * Overides Throwable - */ - public String getMessage() - { - return message; - } - - /** - * Overides Object - */ - public String toString() - { - return message; - } - -} diff --git a/src/interfaces/jdbc/postgresql/util/Serialize.java b/src/interfaces/jdbc/postgresql/util/Serialize.java deleted file mode 100644 index 3209f58105..0000000000 --- a/src/interfaces/jdbc/postgresql/util/Serialize.java +++ /dev/null @@ -1,342 +0,0 @@ -package postgresql.util; - -import java.io.*; -import java.lang.*; -import java.lang.reflect.*; -import java.net.*; -import java.util.*; -import java.sql.*; - -/** - * This class uses PostgreSQL's object oriented features to store Java Objects. - * - * It does this by mapping a Java Class name to a table in the database. Each - * entry in this new table then represents a Serialized instance of this - * class. As each entry has an OID (Object IDentifier), this OID can be - * included in another table. - * - * This is too complex to show here, and will be documented in the main - * documents in more detail. - * - */ -public class Serialize -{ - // This is the connection that the instance refers to - protected postgresql.Connection conn; - - // This is the table name - protected String tableName; - - // This is the class name - protected String className; - - // This is the Class for this serialzed object - protected Class ourClass; - - /** - * This creates an instance that can be used to serialize or deserialize - * a Java object from a PostgreSQL table. - */ - public Serialize(postgresql.Connection c,String type) throws SQLException - { - try { - conn = c; - tableName = type.toLowerCase(); - className = toClassName(type); - ourClass = Class.forName(className); - } catch(ClassNotFoundException cnfe) { - throw new PSQLException("postgresql.serial.noclass",type); - } - - // Second check, the type must be a table - boolean status = false; - ResultSet rs = conn.ExecSQL("select typname from pg_type,pg_class where typname=relname and typname='"+type+"'"); - if(rs!=null) { - if(rs.next()) - status=true; - rs.close(); - } - // This should never occur, as postgresql has it's own internal checks - if(!status) - throw new PSQLException("postgresql.serial.table",type); - - // Finally cache the fields within the table - } - - /** - * This fetches an object from a table, given it's OID - * @param oid The oid of the object - * @return Object relating to oid - * @exception SQLException on error - */ - public Object fetch(int oid) throws SQLException - { - try { - Object obj = ourClass.newInstance(); - - // NB: we use java.lang.reflect here to prevent confusion with - // the postgresql.Field - java.lang.reflect.Field f[] = ourClass.getDeclaredFields(); - boolean hasOID=false; - int oidFIELD=-1; - StringBuffer sb = new StringBuffer("select"); - char sep=' '; - for(int i=0;i - * - * If the object has an int called OID, and it is > 0, then - * that value is used for the OID, and the table will be updated. - * If the value of OID is 0, then a new row will be created, and the - * value of OID will be set in the object. This enables an object's - * value in the database to be updateable. - * - * If the object has no int called OID, then the object is stored. However - * if the object is later retrieved, amended and stored again, it's new - * state will be appended to the table, and will not overwrite the old - * entries. - * - * @param o Object to store (must implement Serializable) - * @return oid of stored object - * @exception SQLException on error - */ - public int store(Object o) throws SQLException - { - try { - // NB: we use java.lang.reflect here to prevent confusion with - // the postgresql.Field - java.lang.reflect.Field f[] = ourClass.getDeclaredFields(); - boolean hasOID=false; - int oidFIELD=-1; - boolean update=false; - - // Find out if we have an oid value - for(int i=0;i0; - } - } - - StringBuffer sb = new StringBuffer(update?"update "+tableName+" set":"insert into "+tableName+" values "); - char sep=update?' ':'('; - for(int i=0;i - * - * Because of this, a Class name may not have _ in the name.

- * Another limitation, is that the entire class name (including packages) - * cannot be longer than 32 characters (a limit forced by PostgreSQL). - * - * @param name Class name - * @return PostgreSQL table name - * @exception SQLException on error - */ - public static String toPostgreSQL(String name) throws SQLException - { - name = name.toLowerCase(); - - if(name.indexOf("_")>-1) - throw new PSQLException("postgresql.serial.underscore"); - - if(name.length()>32) - throw new PSQLException("postgresql.serial.namelength",name,new Integer(name.length())); - - return name.replace('.','_'); - } - - - /** - * This converts a postgresql table to a Java Class name, by replacing _ with - * .

- * - * @param name PostgreSQL table name - * @return Class name - * @exception SQLException on error - */ - public static String toClassName(String name) throws SQLException - { - name = name.toLowerCase(); - return name.replace('_','.'); - } - -} diff --git a/src/interfaces/jdbc/postgresql/util/UnixCrypt.java b/src/interfaces/jdbc/postgresql/util/UnixCrypt.java deleted file mode 100644 index f87e62104a..0000000000 --- a/src/interfaces/jdbc/postgresql/util/UnixCrypt.java +++ /dev/null @@ -1,675 +0,0 @@ -package postgresql.util; - -/** - * This class provides us with the ability to encrypt passwords when sent - * over the network stream - * - *

Contains static methods to encrypt and compare - * passwords with Unix encrypted passwords.

- * - *

See - * John Dumas's Java Crypt page for the original source.

- * - * @author jdumas@zgs.com (John Dumas) - */ -public class UnixCrypt extends Object -{ - // - // Null constructor - can't instantiate class - private UnixCrypt() - { - } - - private static final char[] saltChars = - ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./".toCharArray()); - - private static final int ITERATIONS = 16; - - private static final int con_salt[] = - { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, - 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, - 0x0A, 0x0B, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, - 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, - 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, - 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, - 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24, - 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, - 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, - 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, - 0x3D, 0x3E, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, - }; - - private static final boolean shifts2[] = - { - false, false, true, true, true, true, true, true, - false, true, true, true, true, true, true, false - }; - - private static final int skb[][] = - { - { - /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ - 0x00000000, 0x00000010, 0x20000000, 0x20000010, - 0x00010000, 0x00010010, 0x20010000, 0x20010010, - 0x00000800, 0x00000810, 0x20000800, 0x20000810, - 0x00010800, 0x00010810, 0x20010800, 0x20010810, - 0x00000020, 0x00000030, 0x20000020, 0x20000030, - 0x00010020, 0x00010030, 0x20010020, 0x20010030, - 0x00000820, 0x00000830, 0x20000820, 0x20000830, - 0x00010820, 0x00010830, 0x20010820, 0x20010830, - 0x00080000, 0x00080010, 0x20080000, 0x20080010, - 0x00090000, 0x00090010, 0x20090000, 0x20090010, - 0x00080800, 0x00080810, 0x20080800, 0x20080810, - 0x00090800, 0x00090810, 0x20090800, 0x20090810, - 0x00080020, 0x00080030, 0x20080020, 0x20080030, - 0x00090020, 0x00090030, 0x20090020, 0x20090030, - 0x00080820, 0x00080830, 0x20080820, 0x20080830, - 0x00090820, 0x00090830, 0x20090820, 0x20090830, - }, - { - /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */ - 0x00000000, 0x02000000, 0x00002000, 0x02002000, - 0x00200000, 0x02200000, 0x00202000, 0x02202000, - 0x00000004, 0x02000004, 0x00002004, 0x02002004, - 0x00200004, 0x02200004, 0x00202004, 0x02202004, - 0x00000400, 0x02000400, 0x00002400, 0x02002400, - 0x00200400, 0x02200400, 0x00202400, 0x02202400, - 0x00000404, 0x02000404, 0x00002404, 0x02002404, - 0x00200404, 0x02200404, 0x00202404, 0x02202404, - 0x10000000, 0x12000000, 0x10002000, 0x12002000, - 0x10200000, 0x12200000, 0x10202000, 0x12202000, - 0x10000004, 0x12000004, 0x10002004, 0x12002004, - 0x10200004, 0x12200004, 0x10202004, 0x12202004, - 0x10000400, 0x12000400, 0x10002400, 0x12002400, - 0x10200400, 0x12200400, 0x10202400, 0x12202400, - 0x10000404, 0x12000404, 0x10002404, 0x12002404, - 0x10200404, 0x12200404, 0x10202404, 0x12202404, - }, - { - /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */ - 0x00000000, 0x00000001, 0x00040000, 0x00040001, - 0x01000000, 0x01000001, 0x01040000, 0x01040001, - 0x00000002, 0x00000003, 0x00040002, 0x00040003, - 0x01000002, 0x01000003, 0x01040002, 0x01040003, - 0x00000200, 0x00000201, 0x00040200, 0x00040201, - 0x01000200, 0x01000201, 0x01040200, 0x01040201, - 0x00000202, 0x00000203, 0x00040202, 0x00040203, - 0x01000202, 0x01000203, 0x01040202, 0x01040203, - 0x08000000, 0x08000001, 0x08040000, 0x08040001, - 0x09000000, 0x09000001, 0x09040000, 0x09040001, - 0x08000002, 0x08000003, 0x08040002, 0x08040003, - 0x09000002, 0x09000003, 0x09040002, 0x09040003, - 0x08000200, 0x08000201, 0x08040200, 0x08040201, - 0x09000200, 0x09000201, 0x09040200, 0x09040201, - 0x08000202, 0x08000203, 0x08040202, 0x08040203, - 0x09000202, 0x09000203, 0x09040202, 0x09040203, - }, - { - /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */ - 0x00000000, 0x00100000, 0x00000100, 0x00100100, - 0x00000008, 0x00100008, 0x00000108, 0x00100108, - 0x00001000, 0x00101000, 0x00001100, 0x00101100, - 0x00001008, 0x00101008, 0x00001108, 0x00101108, - 0x04000000, 0x04100000, 0x04000100, 0x04100100, - 0x04000008, 0x04100008, 0x04000108, 0x04100108, - 0x04001000, 0x04101000, 0x04001100, 0x04101100, - 0x04001008, 0x04101008, 0x04001108, 0x04101108, - 0x00020000, 0x00120000, 0x00020100, 0x00120100, - 0x00020008, 0x00120008, 0x00020108, 0x00120108, - 0x00021000, 0x00121000, 0x00021100, 0x00121100, - 0x00021008, 0x00121008, 0x00021108, 0x00121108, - 0x04020000, 0x04120000, 0x04020100, 0x04120100, - 0x04020008, 0x04120008, 0x04020108, 0x04120108, - 0x04021000, 0x04121000, 0x04021100, 0x04121100, - 0x04021008, 0x04121008, 0x04021108, 0x04121108, - }, - { - /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ - 0x00000000, 0x10000000, 0x00010000, 0x10010000, - 0x00000004, 0x10000004, 0x00010004, 0x10010004, - 0x20000000, 0x30000000, 0x20010000, 0x30010000, - 0x20000004, 0x30000004, 0x20010004, 0x30010004, - 0x00100000, 0x10100000, 0x00110000, 0x10110000, - 0x00100004, 0x10100004, 0x00110004, 0x10110004, - 0x20100000, 0x30100000, 0x20110000, 0x30110000, - 0x20100004, 0x30100004, 0x20110004, 0x30110004, - 0x00001000, 0x10001000, 0x00011000, 0x10011000, - 0x00001004, 0x10001004, 0x00011004, 0x10011004, - 0x20001000, 0x30001000, 0x20011000, 0x30011000, - 0x20001004, 0x30001004, 0x20011004, 0x30011004, - 0x00101000, 0x10101000, 0x00111000, 0x10111000, - 0x00101004, 0x10101004, 0x00111004, 0x10111004, - 0x20101000, 0x30101000, 0x20111000, 0x30111000, - 0x20101004, 0x30101004, 0x20111004, 0x30111004, - }, - { - /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */ - 0x00000000, 0x08000000, 0x00000008, 0x08000008, - 0x00000400, 0x08000400, 0x00000408, 0x08000408, - 0x00020000, 0x08020000, 0x00020008, 0x08020008, - 0x00020400, 0x08020400, 0x00020408, 0x08020408, - 0x00000001, 0x08000001, 0x00000009, 0x08000009, - 0x00000401, 0x08000401, 0x00000409, 0x08000409, - 0x00020001, 0x08020001, 0x00020009, 0x08020009, - 0x00020401, 0x08020401, 0x00020409, 0x08020409, - 0x02000000, 0x0A000000, 0x02000008, 0x0A000008, - 0x02000400, 0x0A000400, 0x02000408, 0x0A000408, - 0x02020000, 0x0A020000, 0x02020008, 0x0A020008, - 0x02020400, 0x0A020400, 0x02020408, 0x0A020408, - 0x02000001, 0x0A000001, 0x02000009, 0x0A000009, - 0x02000401, 0x0A000401, 0x02000409, 0x0A000409, - 0x02020001, 0x0A020001, 0x02020009, 0x0A020009, - 0x02020401, 0x0A020401, 0x02020409, 0x0A020409, - }, - { - /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */ - 0x00000000, 0x00000100, 0x00080000, 0x00080100, - 0x01000000, 0x01000100, 0x01080000, 0x01080100, - 0x00000010, 0x00000110, 0x00080010, 0x00080110, - 0x01000010, 0x01000110, 0x01080010, 0x01080110, - 0x00200000, 0x00200100, 0x00280000, 0x00280100, - 0x01200000, 0x01200100, 0x01280000, 0x01280100, - 0x00200010, 0x00200110, 0x00280010, 0x00280110, - 0x01200010, 0x01200110, 0x01280010, 0x01280110, - 0x00000200, 0x00000300, 0x00080200, 0x00080300, - 0x01000200, 0x01000300, 0x01080200, 0x01080300, - 0x00000210, 0x00000310, 0x00080210, 0x00080310, - 0x01000210, 0x01000310, 0x01080210, 0x01080310, - 0x00200200, 0x00200300, 0x00280200, 0x00280300, - 0x01200200, 0x01200300, 0x01280200, 0x01280300, - 0x00200210, 0x00200310, 0x00280210, 0x00280310, - 0x01200210, 0x01200310, 0x01280210, 0x01280310, - }, - { - /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */ - 0x00000000, 0x04000000, 0x00040000, 0x04040000, - 0x00000002, 0x04000002, 0x00040002, 0x04040002, - 0x00002000, 0x04002000, 0x00042000, 0x04042000, - 0x00002002, 0x04002002, 0x00042002, 0x04042002, - 0x00000020, 0x04000020, 0x00040020, 0x04040020, - 0x00000022, 0x04000022, 0x00040022, 0x04040022, - 0x00002020, 0x04002020, 0x00042020, 0x04042020, - 0x00002022, 0x04002022, 0x00042022, 0x04042022, - 0x00000800, 0x04000800, 0x00040800, 0x04040800, - 0x00000802, 0x04000802, 0x00040802, 0x04040802, - 0x00002800, 0x04002800, 0x00042800, 0x04042800, - 0x00002802, 0x04002802, 0x00042802, 0x04042802, - 0x00000820, 0x04000820, 0x00040820, 0x04040820, - 0x00000822, 0x04000822, 0x00040822, 0x04040822, - 0x00002820, 0x04002820, 0x00042820, 0x04042820, - 0x00002822, 0x04002822, 0x00042822, 0x04042822, - }, - }; - - private static final int SPtrans[][] = - { - { - /* nibble 0 */ - 0x00820200, 0x00020000, 0x80800000, 0x80820200, - 0x00800000, 0x80020200, 0x80020000, 0x80800000, - 0x80020200, 0x00820200, 0x00820000, 0x80000200, - 0x80800200, 0x00800000, 0x00000000, 0x80020000, - 0x00020000, 0x80000000, 0x00800200, 0x00020200, - 0x80820200, 0x00820000, 0x80000200, 0x00800200, - 0x80000000, 0x00000200, 0x00020200, 0x80820000, - 0x00000200, 0x80800200, 0x80820000, 0x00000000, - 0x00000000, 0x80820200, 0x00800200, 0x80020000, - 0x00820200, 0x00020000, 0x80000200, 0x00800200, - 0x80820000, 0x00000200, 0x00020200, 0x80800000, - 0x80020200, 0x80000000, 0x80800000, 0x00820000, - 0x80820200, 0x00020200, 0x00820000, 0x80800200, - 0x00800000, 0x80000200, 0x80020000, 0x00000000, - 0x00020000, 0x00800000, 0x80800200, 0x00820200, - 0x80000000, 0x80820000, 0x00000200, 0x80020200, - }, - { - /* nibble 1 */ - 0x10042004, 0x00000000, 0x00042000, 0x10040000, - 0x10000004, 0x00002004, 0x10002000, 0x00042000, - 0x00002000, 0x10040004, 0x00000004, 0x10002000, - 0x00040004, 0x10042000, 0x10040000, 0x00000004, - 0x00040000, 0x10002004, 0x10040004, 0x00002000, - 0x00042004, 0x10000000, 0x00000000, 0x00040004, - 0x10002004, 0x00042004, 0x10042000, 0x10000004, - 0x10000000, 0x00040000, 0x00002004, 0x10042004, - 0x00040004, 0x10042000, 0x10002000, 0x00042004, - 0x10042004, 0x00040004, 0x10000004, 0x00000000, - 0x10000000, 0x00002004, 0x00040000, 0x10040004, - 0x00002000, 0x10000000, 0x00042004, 0x10002004, - 0x10042000, 0x00002000, 0x00000000, 0x10000004, - 0x00000004, 0x10042004, 0x00042000, 0x10040000, - 0x10040004, 0x00040000, 0x00002004, 0x10002000, - 0x10002004, 0x00000004, 0x10040000, 0x00042000, - }, - { - /* nibble 2 */ - 0x41000000, 0x01010040, 0x00000040, 0x41000040, - 0x40010000, 0x01000000, 0x41000040, 0x00010040, - 0x01000040, 0x00010000, 0x01010000, 0x40000000, - 0x41010040, 0x40000040, 0x40000000, 0x41010000, - 0x00000000, 0x40010000, 0x01010040, 0x00000040, - 0x40000040, 0x41010040, 0x00010000, 0x41000000, - 0x41010000, 0x01000040, 0x40010040, 0x01010000, - 0x00010040, 0x00000000, 0x01000000, 0x40010040, - 0x01010040, 0x00000040, 0x40000000, 0x00010000, - 0x40000040, 0x40010000, 0x01010000, 0x41000040, - 0x00000000, 0x01010040, 0x00010040, 0x41010000, - 0x40010000, 0x01000000, 0x41010040, 0x40000000, - 0x40010040, 0x41000000, 0x01000000, 0x41010040, - 0x00010000, 0x01000040, 0x41000040, 0x00010040, - 0x01000040, 0x00000000, 0x41010000, 0x40000040, - 0x41000000, 0x40010040, 0x00000040, 0x01010000, - }, - { - /* nibble 3 */ - 0x00100402, 0x04000400, 0x00000002, 0x04100402, - 0x00000000, 0x04100000, 0x04000402, 0x00100002, - 0x04100400, 0x04000002, 0x04000000, 0x00000402, - 0x04000002, 0x00100402, 0x00100000, 0x04000000, - 0x04100002, 0x00100400, 0x00000400, 0x00000002, - 0x00100400, 0x04000402, 0x04100000, 0x00000400, - 0x00000402, 0x00000000, 0x00100002, 0x04100400, - 0x04000400, 0x04100002, 0x04100402, 0x00100000, - 0x04100002, 0x00000402, 0x00100000, 0x04000002, - 0x00100400, 0x04000400, 0x00000002, 0x04100000, - 0x04000402, 0x00000000, 0x00000400, 0x00100002, - 0x00000000, 0x04100002, 0x04100400, 0x00000400, - 0x04000000, 0x04100402, 0x00100402, 0x00100000, - 0x04100402, 0x00000002, 0x04000400, 0x00100402, - 0x00100002, 0x00100400, 0x04100000, 0x04000402, - 0x00000402, 0x04000000, 0x04000002, 0x04100400, - }, - { - /* nibble 4 */ - 0x02000000, 0x00004000, 0x00000100, 0x02004108, - 0x02004008, 0x02000100, 0x00004108, 0x02004000, - 0x00004000, 0x00000008, 0x02000008, 0x00004100, - 0x02000108, 0x02004008, 0x02004100, 0x00000000, - 0x00004100, 0x02000000, 0x00004008, 0x00000108, - 0x02000100, 0x00004108, 0x00000000, 0x02000008, - 0x00000008, 0x02000108, 0x02004108, 0x00004008, - 0x02004000, 0x00000100, 0x00000108, 0x02004100, - 0x02004100, 0x02000108, 0x00004008, 0x02004000, - 0x00004000, 0x00000008, 0x02000008, 0x02000100, - 0x02000000, 0x00004100, 0x02004108, 0x00000000, - 0x00004108, 0x02000000, 0x00000100, 0x00004008, - 0x02000108, 0x00000100, 0x00000000, 0x02004108, - 0x02004008, 0x02004100, 0x00000108, 0x00004000, - 0x00004100, 0x02004008, 0x02000100, 0x00000108, - 0x00000008, 0x00004108, 0x02004000, 0x02000008, - }, - { - /* nibble 5 */ - 0x20000010, 0x00080010, 0x00000000, 0x20080800, - 0x00080010, 0x00000800, 0x20000810, 0x00080000, - 0x00000810, 0x20080810, 0x00080800, 0x20000000, - 0x20000800, 0x20000010, 0x20080000, 0x00080810, - 0x00080000, 0x20000810, 0x20080010, 0x00000000, - 0x00000800, 0x00000010, 0x20080800, 0x20080010, - 0x20080810, 0x20080000, 0x20000000, 0x00000810, - 0x00000010, 0x00080800, 0x00080810, 0x20000800, - 0x00000810, 0x20000000, 0x20000800, 0x00080810, - 0x20080800, 0x00080010, 0x00000000, 0x20000800, - 0x20000000, 0x00000800, 0x20080010, 0x00080000, - 0x00080010, 0x20080810, 0x00080800, 0x00000010, - 0x20080810, 0x00080800, 0x00080000, 0x20000810, - 0x20000010, 0x20080000, 0x00080810, 0x00000000, - 0x00000800, 0x20000010, 0x20000810, 0x20080800, - 0x20080000, 0x00000810, 0x00000010, 0x20080010, - }, - { - /* nibble 6 */ - 0x00001000, 0x00000080, 0x00400080, 0x00400001, - 0x00401081, 0x00001001, 0x00001080, 0x00000000, - 0x00400000, 0x00400081, 0x00000081, 0x00401000, - 0x00000001, 0x00401080, 0x00401000, 0x00000081, - 0x00400081, 0x00001000, 0x00001001, 0x00401081, - 0x00000000, 0x00400080, 0x00400001, 0x00001080, - 0x00401001, 0x00001081, 0x00401080, 0x00000001, - 0x00001081, 0x00401001, 0x00000080, 0x00400000, - 0x00001081, 0x00401000, 0x00401001, 0x00000081, - 0x00001000, 0x00000080, 0x00400000, 0x00401001, - 0x00400081, 0x00001081, 0x00001080, 0x00000000, - 0x00000080, 0x00400001, 0x00000001, 0x00400080, - 0x00000000, 0x00400081, 0x00400080, 0x00001080, - 0x00000081, 0x00001000, 0x00401081, 0x00400000, - 0x00401080, 0x00000001, 0x00001001, 0x00401081, - 0x00400001, 0x00401080, 0x00401000, 0x00001001, - }, - { - /* nibble 7 */ - 0x08200020, 0x08208000, 0x00008020, 0x00000000, - 0x08008000, 0x00200020, 0x08200000, 0x08208020, - 0x00000020, 0x08000000, 0x00208000, 0x00008020, - 0x00208020, 0x08008020, 0x08000020, 0x08200000, - 0x00008000, 0x00208020, 0x00200020, 0x08008000, - 0x08208020, 0x08000020, 0x00000000, 0x00208000, - 0x08000000, 0x00200000, 0x08008020, 0x08200020, - 0x00200000, 0x00008000, 0x08208000, 0x00000020, - 0x00200000, 0x00008000, 0x08000020, 0x08208020, - 0x00008020, 0x08000000, 0x00000000, 0x00208000, - 0x08200020, 0x08008020, 0x08008000, 0x00200020, - 0x08208000, 0x00000020, 0x00200020, 0x08008000, - 0x08208020, 0x00200000, 0x08200000, 0x08000020, - 0x00208000, 0x00008020, 0x08008020, 0x08200000, - 0x00000020, 0x08208000, 0x00208020, 0x00000000, - 0x08000000, 0x08200020, 0x00008000, 0x00208020 - } - }; - - private static final int cov_2char[] = - { - 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, - 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, - 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, - 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, - 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62, - 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, - 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, - 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A - }; - - private static final int byteToUnsigned(byte b) - { - int value = (int)b; - - return(value >= 0 ? value : value + 256); - } - - private static int fourBytesToInt(byte b[], int offset) - { - int value; - - value = byteToUnsigned(b[offset++]); - value |= (byteToUnsigned(b[offset++]) << 8); - value |= (byteToUnsigned(b[offset++]) << 16); - value |= (byteToUnsigned(b[offset++]) << 24); - - return(value); - } - - private static final void intToFourBytes(int iValue, byte b[], int offset) - { - b[offset++] = (byte)((iValue) & 0xff); - b[offset++] = (byte)((iValue >>> 8 ) & 0xff); - b[offset++] = (byte)((iValue >>> 16) & 0xff); - b[offset++] = (byte)((iValue >>> 24) & 0xff); - } - - private static final void PERM_OP(int a, int b, int n, int m, int results[]) - { - int t; - - t = ((a >>> n) ^ b) & m; - a ^= t << n; - b ^= t; - - results[0] = a; - results[1] = b; - } - - private static final int HPERM_OP(int a, int n, int m) - { - int t; - - t = ((a << (16 - n)) ^ a) & m; - a = a ^ t ^ (t >>> (16 - n)); - - return(a); - } - - private static int [] des_set_key(byte key[]) - { - int schedule[] = new int[ITERATIONS * 2]; - - int c = fourBytesToInt(key, 0); - int d = fourBytesToInt(key, 4); - - int results[] = new int[2]; - - PERM_OP(d, c, 4, 0x0f0f0f0f, results); - d = results[0]; c = results[1]; - - c = HPERM_OP(c, -2, 0xcccc0000); - d = HPERM_OP(d, -2, 0xcccc0000); - - PERM_OP(d, c, 1, 0x55555555, results); - d = results[0]; c = results[1]; - - PERM_OP(c, d, 8, 0x00ff00ff, results); - c = results[0]; d = results[1]; - - PERM_OP(d, c, 1, 0x55555555, results); - d = results[0]; c = results[1]; - - d = (((d & 0x000000ff) << 16) | (d & 0x0000ff00) | - ((d & 0x00ff0000) >>> 16) | ((c & 0xf0000000) >>> 4)); - c &= 0x0fffffff; - - int s, t; - int j = 0; - - for(int i = 0; i < ITERATIONS; i ++) - { - if(shifts2[i]) - { - c = (c >>> 2) | (c << 26); - d = (d >>> 2) | (d << 26); - } - else - { - c = (c >>> 1) | (c << 27); - d = (d >>> 1) | (d << 27); - } - - c &= 0x0fffffff; - d &= 0x0fffffff; - - s = skb[0][ (c ) & 0x3f ]| - skb[1][((c >>> 6) & 0x03) | ((c >>> 7) & 0x3c)]| - skb[2][((c >>> 13) & 0x0f) | ((c >>> 14) & 0x30)]| - skb[3][((c >>> 20) & 0x01) | ((c >>> 21) & 0x06) | - ((c >>> 22) & 0x38)]; - - t = skb[4][ (d ) & 0x3f ]| - skb[5][((d >>> 7) & 0x03) | ((d >>> 8) & 0x3c)]| - skb[6][ (d >>>15) & 0x3f ]| - skb[7][((d >>>21) & 0x0f) | ((d >>> 22) & 0x30)]; - - schedule[j++] = ((t << 16) | (s & 0x0000ffff)) & 0xffffffff; - s = ((s >>> 16) | (t & 0xffff0000)); - - s = (s << 4) | (s >>> 28); - schedule[j++] = s & 0xffffffff; - } - return(schedule); - } - - private static final int D_ENCRYPT - ( - int L, int R, int S, int E0, int E1, int s[] - ) - { - int t, u, v; - - v = R ^ (R >>> 16); - u = v & E0; - v = v & E1; - u = (u ^ (u << 16)) ^ R ^ s[S]; - t = (v ^ (v << 16)) ^ R ^ s[S + 1]; - t = (t >>> 4) | (t << 28); - - L ^= SPtrans[1][(t ) & 0x3f] | - SPtrans[3][(t >>> 8) & 0x3f] | - SPtrans[5][(t >>> 16) & 0x3f] | - SPtrans[7][(t >>> 24) & 0x3f] | - SPtrans[0][(u ) & 0x3f] | - SPtrans[2][(u >>> 8) & 0x3f] | - SPtrans[4][(u >>> 16) & 0x3f] | - SPtrans[6][(u >>> 24) & 0x3f]; - - return(L); - } - - private static final int [] body(int schedule[], int Eswap0, int Eswap1) - { - int left = 0; - int right = 0; - int t = 0; - - for(int j = 0; j < 25; j ++) - { - for(int i = 0; i < ITERATIONS * 2; i += 4) - { - left = D_ENCRYPT(left, right, i, Eswap0, Eswap1, schedule); - right = D_ENCRYPT(right, left, i + 2, Eswap0, Eswap1, schedule); - } - t = left; - left = right; - right = t; - } - - t = right; - - right = (left >>> 1) | (left << 31); - left = (t >>> 1) | (t << 31); - - left &= 0xffffffff; - right &= 0xffffffff; - - int results[] = new int[2]; - - PERM_OP(right, left, 1, 0x55555555, results); - right = results[0]; left = results[1]; - - PERM_OP(left, right, 8, 0x00ff00ff, results); - left = results[0]; right = results[1]; - - PERM_OP(right, left, 2, 0x33333333, results); - right = results[0]; left = results[1]; - - PERM_OP(left, right, 16, 0x0000ffff, results); - left = results[0]; right = results[1]; - - PERM_OP(right, left, 4, 0x0f0f0f0f, results); - right = results[0]; left = results[1]; - - int out[] = new int[2]; - - out[0] = left; out[1] = right; - - return(out); - } - - /** - *

Encrypt a password given the cleartext password and a "salt".

- * @param salt A two-character string representing the salt used to - * iterate the encryption engine in lots of different ways. If you - * are generating a new encryption then this value should be - * randomised. - * @param original The password to be encrypted. - * @return A string consisting of the 2-character salt followed by the - * encrypted password. - */ - public static final String crypt(String salt, String original) - { - while(salt.length() < 2) - salt += "A"; - - StringBuffer buffer = new StringBuffer(" "); - - char charZero = salt.charAt(0); - char charOne = salt.charAt(1); - - buffer.setCharAt(0, charZero); - buffer.setCharAt(1, charOne); - - int Eswap0 = con_salt[(int)charZero]; - int Eswap1 = con_salt[(int)charOne] << 4; - - byte key[] = new byte[8]; - - for(int i = 0; i < key.length; i ++) - key[i] = (byte)0; - - for(int i = 0; i < key.length && i < original.length(); i ++) - { - int iChar = (int)original.charAt(i); - - key[i] = (byte)(iChar << 1); - } - - int schedule[] = des_set_key(key); - int out[] = body(schedule, Eswap0, Eswap1); - - byte b[] = new byte[9]; - - intToFourBytes(out[0], b, 0); - intToFourBytes(out[1], b, 4); - b[8] = 0; - - for(int i = 2, y = 0, u = 0x80; i < 13; i ++) - { - for(int j = 0, c = 0; j < 6; j ++) - { - c <<= 1; - - if(((int)b[y] & u) != 0) - c |= 1; - - u >>>= 1; - - if(u == 0) - { - y++; - u = 0x80; - } - buffer.setCharAt(i, (char)cov_2char[c]); - } - } - return(buffer.toString()); - } - - /** - *

Encrypt a password given the cleartext password. This method - * generates a random salt using the 'java.util.Random' class.

- * @param original The password to be encrypted. - * @return A string consisting of the 2-character salt followed by the - * encrypted password. - */ - public static final String crypt(String original) - { - java.util.Random randomGenerator = new java.util.Random(); - int numSaltChars = saltChars.length; - String salt; - - salt = (new StringBuffer()).append(saltChars[Math.abs(randomGenerator.nextInt()) % numSaltChars]).append(saltChars[Math.abs(randomGenerator.nextInt()) % numSaltChars]).toString(); - - return crypt(salt, original); - } - - /** - *

Check that enteredPassword encrypts to - * encryptedPassword.

- * @param encryptedPassword The encryptedPassword. The first - * two characters are assumed to be the salt. This string would - * be the same as one found in a Unix /etc/passwd file. - * @param enteredPassword The password as entered by the user (or - * otherwise aquired). - * @return true if the password should be considered correct. - */ - public final static boolean matches(String encryptedPassword, String enteredPassword) - { - String salt = encryptedPassword.substring(0, 3); - String newCrypt = crypt(salt, enteredPassword); - - return newCrypt.equals(encryptedPassword); - } -} -