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
- * 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;p 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;p 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 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.
- *
- * 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:
- *
- *
- *
- * 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:
- * 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:
- * 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:
- *
- * 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 The schema column is:
- * The catalog column is:
- * The table type is:
- * Each column description has the following 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:
- * 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:
- * Each column description has the following columns:
- * Each column description has the following columns:
- * Each column description has the following columns:
- * Each primary key column description has the following columns:
- * Each foreign key column description has the following columns:
- * Each foreign key column description has the following columns:
- * Each type description has the following columns:
- * Each index column description has the following columns:
- * 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:
- * 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 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.
- *
- * 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:
- *
- *
- *
- * 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:
- * 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:
- * 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:
- *
- * 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 The schema column is:
- * The catalog column is:
- * The table type is:
- * Each column description has the following 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:
- * 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:
- * Each column description has the following columns:
- * Each column description has the following columns:
- * Each column description has the following columns:
- * Each primary key column description has the following columns:
- * Each foreign key column description has the following columns:
- * Each foreign key column description has the following columns:
- * Each type description has the following columns:
- * Each index column description has the following columns:
- * 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:
- * 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;i 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:
- * 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
- * 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
- * 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. Encrypt a password given the cleartext password and a "salt". Encrypt a password given the cleartext password. This method
- * generates a random salt using the 'java.util.Random' class. Check that enteredPassword encrypts to
- * encryptedPassword.
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;i
- * 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.
- *
- *
- * 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;
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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;i
- *
- *
- * @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
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
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.
- *
- *
- * 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.
- *
- *
- * 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;
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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;i
- *
- *
- * @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
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
- *
- *
- *
- *
- * @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.
- *
- *
- *
- *
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.
- *
- *
- * import postgresql.largeobject.*;
- *
- * Connection conn;
- * LargeObjectManager lobj;
- *
- * ... code that opens a connection ...
- *
- * lobj = ((postgresql.Connection)myconn).getLargeObjectAPI();
- *
- *
- *
This method should only be called by postgresql.Connection
- *
- *