PostgreSQL 是一种可扩展的数据库系统。 你可以向数据库后端里增加你自己的函数，这些函数可以供查询调用， 甚至你可以增加你自己的数据类型。因为这些是 PostgreSQL 特有的功能，因此我们在 Java 里面支持它们，同时还带着一套扩展的 API。在标准驱动的核心里实际上使用了这些扩展来实现大对象等等。
要获得某些扩展，你需要使用 org.postgresql.PGConnection 类里的一些额外的方法，这时，你需要转换 Driver.getConnection() 的返回值。比如∶
Connection db = Driver.getConnection(url, username, password); // ... // 稍后 Fastpath fp = ((org.postgresql.PGConnection)db).getFastpathAPI();
public class PGConnection
这些是用于获取 PostgreSQL 的扩展的额外的方法。
public Fastpath getFastpathAPI() throws SQLException
这个方法为当前联接返回 Fastpath API。 主要用于大对象API。
使用这个方法的最好方式是∶
import org.postgresql.fastpath.*; ... Fastpath fp = ((org.postgresql.PGConnection)myconn).getFastpathAPI();
这里的myconn是一个已经打开的与 PostgreSQL 的Connection。
返回：. 一个可以用来访问 PostgreSQL 后端里面的函数的 Fastpath 对象。
抛出：. 在第一次初始化的时候 Fastpath 抛出的SQLException。
public LargeObjectManager getLargeObjectAPI() throws SQLException
这个方法为当前联接返回一个大对象 API。
使用这个方法的最佳手段如下∶
import org.postgresql.largeobject.*; ... LargeObjectManager lo = ((org.postgresql.PGConnection)myconn).getLargeObjectAPI();
这里的myconn是一个已经打开的与 PostgreSQL 的Connection。
返回：. 实现大对象 API 的LargeObject对象。
抛出：. 在第一次初始化的时候LargeObject抛出的 SQLException。
public void addDataType(String type, String name)
这个方法允许客户端代码为PostgreSQL中比较独特的数据类型加一个句柄。 通常，驱动器不认识的数据类型是由 ResultSet.getObject() 以一个PGobject实例的形式返回的。 这个方法允许你写一个扩展PGobject 的类，然后告诉驱动该类型名字，以及要使用的类名字。 这个方法的缺点是，每次你建立新联接的时候，你都要调用这个方法。
使用这个用法的最佳手段是：
...
((org.postgresql.PGConnection)myconn).addDataType("mytype","my.class.name");
...这里的myconn是一个已经打开的与 PostgreSQL 的Connection。做控制的类必须扩展 org.postgresql.util.PGobject。
public class Fastpath extends Object java.lang.Object | +----org.postgresql.fastpath.Fastpath
Fastpath是一套存在于libpqC 接口里的 API ， 并且这个接口允许客户机器执行后端数据库的函数. 大多数客户端代码不需要使用这个方法，但是我们还是提供这个方法， 因为大对象 API 使用它。
要使用这个扩展，你需要输入 postgresql.fastpath包，使用下面行：
import org.postgresql.fastpath.*;
然后，在你的代码里，你需要获取一个FastPath对象：
Fastpath fp = ((org.postgresql.PGConnection)conn).getFastpathAPI();
这样将返回一个实例，该实例与你发出命令的数据库联接相关联。 必须把Connection转换成 org.postgresql.PGConnection， 因为getFastpathAPI()是我们自己的方法之一，而不是 JDBC的。 一旦你拥有了 Fastpath 实例， 你就可以使用 fastpath() 方法执行一个后端函数。
又见：. FastpathFastpathArg, LargeObject
public Object fastpath(int fnid,
boolean resulttype,
FastpathArg args[]) throws SQLException向PostgreSQL后端发送一个函数调用。
参数：. fnid - 函数 id resulttype - 如果结果为整数则为真，如果为其它则为假 args - 传递给捷径的 FastpathArguments
返回：. 如果没有数据返回空(null), 如果结果为整数返回一个Integer, 否则返回 byte[]
public Object fastpath(String name,
boolean resulttype,
FastpathArg args[]) throws SQLException通过名字向PostgreSQL后端发送一个函数调用。
注意: 函数名到函数 id 的映射必须存在, 通常先调用 addfunction()。 这是调用函数的优选方法，因为函数 id 在不同版本的后端里是会/可能改变的。 这个方法工作的例子，可以参阅 org.postgresql.LargeObject。
参数：. name - 函数名称 resulttype - 如果结果是整数返回真 (true), 其他结果返回假 (false) args - 传递给 fastpath 的参数FastpathArguments
返回∶. 如果没有数据返回空 (null), 如果结果为整数返回一个 Integer, 否则返回 byte[]
又见：. LargeObject
public int getInteger(String name,
FastpathArg args[]) throws SQLException这个便利方法假设返回值是一个 Integer (整数)
参数：. name - 函数名 args - 函数参数
返回：. 整数结果
抛出：. 如果发生了数据库访问错误或者没有结果抛出 SQLException。
public byte[] getData(String name,
FastpathArg args[]) throws SQLException这个便利方法假设返回值是二进制数据
参数：. name - 函数名 args - 函数参数
返回：. 包含结果的 byte[] 数组
抛出：. 如果发生了数据库访问错误或者没有结果抛出SQLException?
public void addFunction(String name,
int fnid)这个方法向我们的(函数)检索表里增加一个函数。 用户代码应该使用addFunctions方法， 因为这个方法基于一个查询， 而不是 OID 硬代码。我们不保证一个函数的 OID 是静态的， 甚至运行在不同服务器的同版本的数据库也不能保证是静态的。
public void addFunctions(ResultSet rs) throws SQLException
这个方法接收一个包含两个字段的ResultSet。 字段 1 包含函数名，字段 2 是 OID。 它读取整个ResultSet，把值装载入函数表.
Important: 调用完这个方法后记得用close()关闭 ResultSet!!
关于函数名查找实现的信息: PostgreSQL 在pg_proc表里存储函数 id 和它们对应的名称， 在查找时不是从该表里查询每个所需函数的名称， 而是使用了一个Hashtable (散列表)。 同样，只有需要的函数的名称才放到这个表里，以保证连接速度尽可能快。
org.postgresql.LargeObject 类在启动时执行一个查询, 并且把返回的 ResultSet 传递给这里提到的 addFunctions()方法。 一旦这些工作完成，LargeObjectAPI就用名称引用函数。
不要以为手工把它们转换成 OID 就可以了。 的确，目前这样做是可以用的，但随着开发的进行这些可能被修改 （在 V7.0 版本的讨论中有一些关于这些的话题）， 所以这样做是防止未来可能出现的任何不受保障的痛苦的手段。
又见：. LargeObjectManager
public int getID(String name) throws SQLException
这个方法返回与函数名关联的函数 id， 如果还没有对这个函数名调用 addFunction()或 addFunctions()， 那么抛出一个SQLException。
public class FastpathArg extends Object java.lang.Object | +----org.postgresql.fastpath.FastpathArg
每个 fastpath 调用都需要一个参数列表，其数目和类型取决于被调用的函数。 这个类实现了提供这个功能所需要的方法。
关于如何使用这个方法的例子, 参阅 org.postgresql.LargeObject 包
又见：. Fastpath, LargeObjectManager, LargeObject
public FastpathArg(int value)
构造一个包含一个整数值的参数
参数：. value - 待设置的整数值
public FastpathArg(byte bytes[])
构造一个包含一个字节数组的参数
参数：. bytes - 要保存的数组
public FastpathArg(byte buf[],
int off,
int len)构造一个包含一个数组的一部分的参数
参数：.
源数组
数组内的偏移量
要包括的数据的长度
public FastpathArg(String s)
构造一个字符串组成的参数。
PostgreSQL 有一个往表里存储几何特性的数据类型集。 范围包括点，线，和多边形。 我们通过 org.postgresql.geometric 包在 Java 里支持这些类型。 它包括扩展了 org.postgresql.util.PGobject 类的类。 参考该类获取如何实现你自己的数据类型的控制器的细节。
Class org.postgresql.geometric.PGbox
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.geometric.PGbox
public class PGbox extends PGobject implements Serializable,
Cloneable
这个类在PostgreSQL里表示盒子 (box) 数据类型。
变量
public PGpoint point[]
这些是盒子的两个对角点。
构造器
public PGbox(double x1,
double y1,
double x2,
double y2)
参数∶
x1 - 第一个 x 坐标
y1 - 第一个 y 坐标
x2 - 第二个 x 坐标
y2 - 第二个 y 坐标
public PGbox(PGpoint p1,
PGpoint p2)
参数∶
p1 - 第一个点
p2 - 第二个点
public PGbox(String s) throws SQLException
参数∶
s -PostgreSQL语法里的盒子定义
抛出∶ SQLException
如果定义非法
public PGbox()
必须的构造(方法)
方法
public void setValue(String value) throws SQLException
这个方法设置这个对象的值。它应该被重载，但是仍然被子类调用。
参数∶
value - 一个代表对象值的字符串
抛出∶ SQLException
如果此数值对这个类型而言是非法的
覆盖∶
类 PGobject 里的 setValue
public boolean equals(Object obj)
参数∶
obj - 要比较的对象
返回∶
如果两个盒子相等返回真 (true)
覆盖∶
类 PGobject 里的 equals
public Object clone()
必须覆盖这个方法以允许对象被克隆 (cloned)
覆盖∶
类 PGobject 里的 equals
public String getValue()
返回∶
PostgreSQL句法需要的 PGbox
覆盖∶
getValue in class PGobject
Class org.postgresql.geometric.PGcircle
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.geometric.PGcircle
public class PGcircle extends PGobject implements Serializable,
Cloneable
这个类代表 PostgreSQL 的圆数据类型，由一个点和一个半径组成
变量
public PGpoint center
这是圆心
double radius
这是半径
构造器
public PGcircle(double x,
double y,
double r)
参数∶
x - 圆心坐标
y - 圆心坐标
r - 圆半径
public PGcircle(PGpoint c,
double r)
参数∶
c - 描述圆心的 PGpoint
r - 圆半径
public PGcircle(String s) throws SQLException
参数∶
s -PostgreSQL里语法定义的圆。
抛出∶ SQLException
如果转换失败
public PGcircle()
这个构造(方法)被驱动器使用。
方法
public void setValue(String s) throws SQLException
参数∶
s - 用PostgreSQL的语法定义的圆。
抛出∶ SQLException
如果转换失败
覆盖∶
类 PGobject 里的 setValue
public boolean equals(Object obj)
参数∶
obj - 要对比的对象
返回∶
如果两个圆相同返回真 (true)
覆盖∶
类 PGobject 里的 equals
public Object clone()
必须重载这个方法以便允许对象被克隆 (cloned)
覆盖∶
类 PGobject 里的 clone
public String getValue()
返回∶
PostgreSQL 语法里的 PGcircle 字串
覆盖∶
PGobject 里的 getValue
Class org.postgresql.geometric.PGline
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.geometric.PGline
public class PGline extends PGobject implements Serializable,
Cloneable
这个类实现由两个点组成的线。目前线还没有在后端实现，
但这个类保证在后端实现后即可使用(线)。
变量
public PGpoint point[]
这是两个点。
构造器
public PGline(double x1,
double y1,
double x2,
double y2)
参数∶
x1 - 第一个点的x坐标
y1 - 第一个点的y坐标
x2 - 第二个点的x坐标
y2 - 第二个点的y坐标
public PGline(PGpoint p1,
PGpoint p2)
参数∶
p1 - 第一个点
p2 - 第二个点
public PGline(String s) throws SQLException
参数∶
s -PostgreSQL语法定义的点。
抛出∶ SQLException
当发生转换错误时
public PGline()
驱动需要
方法
public void setValue(String s) throws SQLException
参数∶
s -PostgreSQL里语法的线段的定义
抛出∶ SQLException
当发生转换错误时
覆盖∶
类 PGobject 里的 setValue
public boolean equals(Object obj)
参数∶
obj - 要比较的对象
返回∶
如果两条线段相同返回真 (true)
覆盖∶
类 PGobject 里的 equals
public Object clone()
这个方法必须被重载以便允许这个对象可以被克隆
覆盖∶
类 PGobject 里的 clone
public String getValue()
返回∶
PostgreSQL 语法里的 PGline
覆盖∶
类 PGobject 里的 getValue
Class org.postgresql.geometric.PGlseg
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.geometric.PGlseg
public class PGlseg extends PGobject implements Serializable,
Cloneable
这样实现了一条包含两个点的 lseg (线段)
变量
public PGpoint point[]
这里是两个点
构造器
public PGlseg(double x1,
double y1,
double x2,
double y2)
参数∶
x1 - 第一个点的x坐标
y1 - 第一个点的y坐标
x2 - 第二个点的x坐标
y2 - 第二个点的y坐标
public PGlseg(PGpoint p1,
PGpoint p2)
参数∶
p1 - 第一个点
p2 - 第二个点
public PGlseg(String s) throws SQLException
参数∶
s -PostgreSQL里语法对线段定义的字串。
抛出∶ SQLException
在发生转换错误时
public PGlseg()
驱动要求
方法
public void setValue(String s) throws SQLException
参数∶
s -PostgreSQL里语法对线段定义的字串
抛出∶ SQLException
在发生转换错误时
覆盖∶
类 PGobject 里的 setValue
public boolean equals(Object obj)
参数∶
obj - 要比较的对象
返回∶
如果两条线段相等
覆盖∶
类 PGobject 里的 equals
public Object clone()
必须覆盖这个方法以便允许这个对象被克隆
覆盖∶
类 PGobject 里的 getValue
public String getValue()
返回∶
PostgreSQL 语法里的 PGlseg
覆盖∶
类 PGobject 里的 getValue
Class org.postgresql.geometric.PGpath
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.geometric.PGpath
public class PGpath extends PGobject implements Serializable,
Cloneable
这是路径( 多线段图形, 可以为封闭的 )的实现
变量
public boolean open
如果路径开放时为真 (True)，为封闭时为假
public PGpoint points[]
定义路径的点
构造器
public PGpath(PGpoint points[],
boolean open)
参数∶
points - 定义路径的 PGpoints
open - 如果路径是开放的为真 (True)，封闭为假 (false)
public PGpath()
驱动需要
public PGpath(String s) throws SQLException
参数∶
s -PostgreSQL的语法定义的路径。
抛出∶ SQLException
在发生转换错误时
方法
public void setValue(String s) throws SQLException
参数∶
s -PostgreSQL的语法定义的路径的字串
抛出∶ SQLException
在发生转换失败时
覆盖∶
类 PGobject 里的 setValue
public boolean equals(Object obj)
参数∶
obj - 要比较的对象
返回∶
如果两个路径相同返回真 (true)
覆盖∶
类 PGobject 里的 equals
public Object clone()
必须覆盖这个方法以便允许这个对象被克隆
覆盖∶
clone in class PGobject
public String getValue()
这个方法返回PostgreSQL语法的多边形
覆盖∶
类 PGobject 里的 getValue
public boolean isOpen()
如果路径是开放的这个方法返回真 (true)
public boolean isClosed()
如果路径是封闭的这个方法返回真 (true)
public void closePath()
标记路径为封闭
public void openPath()
标记路径为开放
Class org.postgresql.geometric.PGpoint
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.geometric.PGpoint
public class PGpoint extends PGobject implements Serializable,
Cloneable
这个类实现了 java.awt.Point 的一个版本，但用 double 表示参数。
它对应于 PostgreSQL 里的 point 数据类型。
变量
public double x
点的 X 坐标
public double y
点的 Y 坐标
构造器
public PGpoint(double x,
double y)
参数∶
x - 坐标
y - 坐标
public PGpoint(String value) throws SQLException
这个方法主要从其他几何类型调用 -- 当一个点嵌入它们的定义中时。
参数∶
value -PostgreSQL语法定义的点
public PGpoint()
驱动需要
方法
public void setValue(String s) throws SQLException
参数∶
s -PostgreSQL语法定义的点
抛出∶ SQLException
在转换失败时
覆盖∶
类 PGobject 里的 setValue
public boolean equals(Object obj)
参数∶
obj - 要比较的对象
返回∶
如果两个对象相同返回真 (true)
覆盖∶
类 PGobject 里的 equals
public Object clone()
必须覆盖这个方法以便允许这个对象被克隆
覆盖∶
类 PGobject 里的 clone
public String getValue()
返回∶
PostgreSQL里语法 PGpoint 的表示。
覆盖∶
类 PGobject 里的 getValue
public void translate(int x,
int y)
对点做指定数量的转换(位移)。
参数∶
x - 向 x 轴增加的整型数量
y - 向 y 轴增加的整型数量
public void translate(double x,
double y)
对点做指定数量的转换(位移)。
参数∶
x - 向 x 轴增加的双精度型数量
y - 向 y 轴增加的双精度型数量
public void move(int x,
int y)
把点移到指定坐标。
参数∶
x - 整数坐标
y - 整数坐标
public void move(double x,
double y)
把点移到指定坐标。
参数∶
x - 双精度坐标
y - 双精度坐标
public void setLocation(int x,
int y)
把点移到指定坐标. 参考
java.awt.Point 获取这个方法的描述信息
参数∶
x - 整数坐标
y - 整数坐标
又见∶
Point
public void setLocation(Point p)
把点移到指定坐标. 参考
java.awt.Point 获取这个方法的描述信息
参数∶
p - 移动的目的点 (Point)
又见∶
Point
Class org.postgresql.geometric.PGpolygon
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.geometric.PGpolygon
public class PGpolygon extends PGobject implements Serializable,
Cloneable
这个类在PostgreSQL里实现了 polygon (多边形)数据类型。
变量
public PGpoint points[]
定义 polygon (多边形)的点
构造器
public PGpolygon(PGpoint points[])
使用一个 PGpoints 数组创建一个多边形
参数∶
points - 定义多边形 polygon 的点
public PGpolygon(String s) throws SQLException
参数∶
s - 用PostgreSQL语法定义的多边形.
抛出∶ SQLException
在转换失败时
public PGpolygon()
驱动需要
方法
public void setValue(String s) throws SQLException
参数∶
s - 用PostgreSQL语法定义的多边形.
抛出∶ SQLException
在转换失败时
覆盖∶
类 PGobject 里的 setValue
public boolean equals(Object obj)
参数∶
obj - 要比较的对象
返回∶
如果两个对象相同返回真 (true)
覆盖∶
类 PGobject 里的 equals
public Object clone()
必须覆盖这个方法以便允许这个对象被克隆
覆盖∶
类 PGobject 里的 clone
public String getValue()
返回∶
PostgreSQL里语法表示的 PGpolygon。
覆盖∶
类 PGobject 里的 getValue标准的 JDBC 规范里也支持大对象。 但是，那个接口有一些限制， 而PostgreSQL提供的 API 允许对对象内容的随机访问， 就象那是一个本地文件一样。
org.postgresql.largeobject 包为 Java 提供了libpq C 接口的大对象 API。它包含两个类， LargeObjectManager， 处理创建，打开和删除大对象的任务；以及 LargeObject，处理独立的对象。
public class LargeObject extends Object java.lang.Object | +----org.postgresql.largeobject.LargeObject
这个类实现PostgreSQL的大对象接口。
它提供运行接口的基本的方法，另外还有一对方法为此对象提供 InputStream 和 OutputStream类。
通常，客户端代码将使用在 BLOB 里的方法访问大对象。
但是，有时候需要低层次的大对象访问方法，那是 JDBC 规范还不支持的。
参考 org.postgresql.largeobject.LargeObjectManager 获取如何访问大对象和如何创建大对象的信息。
又见∶. LargeObjectManager
标识从一个文件的开头进行一次搜索
标识从当前位置进行一次搜索
标识从一个文件的结尾进行一次搜索
public int getOID()
返回这个 LargeObject 的 OID。
public void close() throws SQLException
这个方法关闭对象，在调用这个方法后你不能调用这个对象里的任何方法。
public byte[] read(int len) throws SQLException
从对象读取一些数据, 并且做为 byte[] 数组返回
public int read(byte buf[],
int off,
int len) throws SQLException从对象读取一些数据到现有数组
参数∶.
目的数组
数组内偏移量
读取的字节数
public void write(byte buf[]) throws SQLException
向对象里写入一个数组
public void write(byte buf[],
int off,
int len) throws SQLException从数组里写一些数据到对象
参数∶.
目标数组
数组内偏移量
写入字节数
public class LargeObjectManager extends Object java.lang.Object | +----org.postgresql.largeobject.LargeObjectManager
这个类型实现了PostgreSQL的大对象接口。 它提供了允许客户代码从数据库里创建，打开和删除大对象的方法。 在打开一个对象时，返回一个 postgresql.largeobject.LargeObject的实例， 然后它的方法就可以访问该对象。
这个类只能由 org.postgresql.PGConnection 创建 要访问这个类，使用下面的代码片段：
import org.postgresql.largeobject.*; Connection conn; LargeObjectManager lobj; // ... 打开一个连接的代码 ... lobj = ((org.postgresql.PGConnection)myconn).getLargeObjectAPI();
通常, 客户代码要使用 BLOB 方法访问大对象。 但是，有时候需要低层次的大对象访问方法，那是 JDBC 规范还不支持的。
请参考 org.postgresql.largeobject.LargeObject 获取如何控制大对象内容的信息。
这个模式表明我们要写入大对象
这个模式表明我们要读取大对象
这个模式是缺省的，表明我们要对大对象进行读和写的操作
public LargeObject open(int oid) throws SQLException
这个方法打开一个现有的大对象, 以其 OID 为基础. 这个方法假设 我们需要READ和WRITE访问模式 (缺省模式)。
public LargeObject open(int oid,
int mode) throws SQLException这个方法以其 OID 为基础打开一个现有的大对象。 并且允许设置访问模式。
public int create() throws SQLException
这个方法创建一个大对象, 返回它的 OID。 它把新创建的大对象模式设为缺省的READWRITE。
public int create(int mode) throws SQLException
这个方法创建一个大对象，返回它的 OID。并设置访问模式。
public void delete(int oid) throws SQLException
这个方法删除一个大对象。
public void unlink(int oid) throws SQLException
这个方法删除一个大对象。这个方法等同于 delete 方法， 并且作为类似使用"unlink"的 C API 出现。