pgsql.cc 提供对 postgresql.org 官网内容的中文翻译，由 Pigsty 团队维护。
Postgres 是一个可扩展的数据库 系统。你可以向后端添加自己的函数， 然后从查询中调用它们，甚至添加你自己的数据类型。由于 这些是 Postgres 独有的功能， 我们用一组扩展 API 从 Java 中支持它们。标准驱动 核心中的一些功能实际上就是用这些扩展来实现大对象 等特性的。
要访问其中一些扩展，你需要使用 org.postgresql.Connection 类中的一些额外方法。在这种情况下，你需要对 Driver.getConnection() 的返回值进行强制转换。例如：
Connection db = Driver.getConnection(url, username, password); // ... // later on Fastpath fp = ((org.postgresql.Connection)db).getFastpathAPI();
org.postgresql.Connection 类public class PGConnection
这些是用于访问 PostgreSQL 扩展的额外方法。java.sql.Connection 定义的方法 未列出。
public Fastpath getFastpathAPI() throws SQLException
这将返回当前连接的 Fastpath API。 它主要供大对象 API 使用。
使用它的最佳方式如下：
import org.postgresql.fastpath.*; ... Fastpath fp = ((org.postgresql.Connection)myconn).getFastpathAPI();
其中 myconn 是一个到 PostgreSQL 的已打开的 Connection。
返回：. 一个允许访问 PostgreSQL 后端上函数的 Fastpath 对象。
抛出：. 首次初始化时由 Fastpath 抛出的 SQLException
public LargeObjectManager getLargeObjectAPI() throws SQLException
这将返回当前连接的大对象 API。
使用它的最佳方式如下：
import org.postgresql.largeobject.*; ... LargeObjectManager lo = ((org.postgresql.Connection)myconn).getLargeObjectAPI();
其中 myconn 是一个到 PostgreSQL 的已打开的 Connection。
返回：. 一个实现了该 API 的 LargeObject 对象
抛出：. 首次初始化时由 LargeObject 抛出的 SQLException
public void addDataType(String type, String name)
这允许客户端代码为 PostgreSQL 较独特的 数据类型之一添加一个处理器。通常，驱动不 认识的数据类型会被 ResultSet.getObject() 作为 PGobject 实例返回。这个方法允许你编写一个 扩展 PGobject 的类，并告诉驱动要使用的 类型名和类名。它的缺点是，每次建立连接时你都必须 调用这个方法。
使用它的最佳方式如下：
...
((org.postgresql.Connection)myconn).addDataType("mytype","my.class.name");
...
其中 myconn 是一个到 PostgreSQL 的已打开的 Connection。处理类必须 扩展 org.postgresql.util.PGobject。
org.postgresql.Fastpath 类public class Fastpath extends Object java.lang.Object | +----org.postgresql.fastpath.Fastpath
Fastpath 是一个存在于 libpq C 接口中的 API， 它允许一台客户端机器在数据库后端上执行一个函数。大多数客户端代码 不需要使用这个方法，但之所以提供它，是因为 大对象 API 用到它。
要使用它，你需要用下面这一行导入 org.postgresql.fastpath 包：
import org.postgresql.fastpath.*;
然后，在你的代码中，你需要获取一个 FastPath 对象：
Fastpath fp = ((org.postgresql.Connection)conn).getFastpathAPI();
这将返回一个与你可用它来发出命令的数据库 连接相关联的实例。必须把 Connection 强制转换为 org.postgresql.Connection，因为 getFastpathAPI() 是一个扩展方法， 不属于 JDBC。一旦你有了一个 Fastpath 实例，就可以使用 fastpath() 方法来执行一个后端 函数。
参见：. FastpathFastpathArg、LargeObject
public Object fastpath(int fnid,
boolean resulttype,
FastpathArg args[]) throws SQLException
向 PostgreSQL 后端发送一次函数调用。
参数：. fnid - 函数 id resulttype - 如果结果是一个整数则为 true， 对于其他结果为 false args - 要传递给 fastpath 的 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，把这些值装入函数表。
记得在调用它之后对 ResultSet 调用 close()！
PostgreSQL 把函数 id 及其对应的 名称存储在 pg_proc 表中。为了在本地加快 速度，不是在需要时从该表中逐个查询函数， 而是使用一个 Hashtable。而且，只有所需的 函数才会被输入到这个表中，以使连接 时间尽可能快。
org.postgresql.LargeObject 类 在启动时执行一次查询，并把返回的 ResultSet 传递给这里的 addFunctions() 方法。完成之后， 大对象 API 就可以按名称 引用这些函数。
不要以为手动把它们转换成 oid 就能 工作。好吧，目前它们可以，但在开发过程中它们可能 改变（V7.0 曾有过一些关于此的讨论）， 因此这样实现是为了避免将来 出现不必要的麻烦。
参见：. LargeObjectManager
public int getID(String name) throws SQLException
这将返回与名称相关联的函数 id。如果没有为这个 名称调用过 addFunction() 或 addFunctions()，那么就会抛出 SQLException。
org.postgresql.fastpath.FastpathArg 类public class FastpathArg extends Object java.lang.Object | +----org.postgresql.fastpath.FastpathArg
每次 fastpath 调用都需要一个参数数组，其数量和 类型取决于被调用的函数。这个类 实现了提供这一能力所需的方法。
关于如何使用它的例子，请参阅 org.postgresql.LargeObject 包。
参见：. Fastpath、LargeObjectManager、LargeObject
public FastpathArg(int value)
构造一个由一个整数值组成的参数
参数：. value - 要设置的 int 值
public FastpathArg(byte bytes[])
构造一个由一个字节数组组成的参数
参数：. bytes - 要存储的数组
public FastpathArg(byte buf[],
int off,
int len)
构造一个由字节数组的一部分组成的参数
参数：.
public FastpathArg(String s)
构造一个由一个 String 组成的参数。
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
如果值对该类型无效则抛出
Overrides:
setValue in class PGobject
public boolean equals(Object obj)
参数：
obj - 要比较的对象
返回值：
如果两个矩形相同则为 true
Overrides:
equals in class PGobject
public Object clone()
必须覆盖此方法才能克隆该对象
Overrides:
clone in class PGobject
public String getValue()
返回值：
按 PostgreSQL 所期望语法表示的 PGbox
Overrides:
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 的 circle 数据类型，由一个点和一个半径组成
变量
public PGpoint center
这是圆心点
public 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
转换失败时
Overrides:
setValue in class PGobject
public boolean equals(Object obj)
参数：
obj - 要比较的对象
返回值：
如果两个矩形相同则为 true
Overrides:
equals in class PGobject
public Object clone()
必须覆盖此方法才能克隆该对象
Overrides:
clone in class PGobject
public String getValue()
返回值：
按 PostgreSQL 所期望语法表示的 PGcircle
Overrides:
getValue in class PGobject
Class org.postgresql.geometric.PGline
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.geometric.PGline
public class PGline extends PGobject implements Serializable,
Cloneable
它实现由两点构成的 line。后端目前尚未实现 line 类型，但这个类保证了在实现之后我们就能直接使用它。
变量
public PGpoint point[]
这就是这两个点。
构造器
public PGline(double x1,
double y1,
double x2,
double y2)
参数：
x1 - 第一个点的坐标
y1 - 第一个点的坐标
x2 - 第二个点的坐标
y2 - 第二个点的坐标
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
转换失败时
Overrides:
setValue in class PGobject
public boolean equals(Object obj)
参数：
obj - 要比较的对象
返回值：
如果两个矩形相同则为 true
Overrides:
equals in class PGobject
public Object clone()
必须覆盖此方法才能克隆该对象
Overrides:
clone in class PGobject
public String getValue()
返回值：
按 PostgreSQL 所期望语法表示的 PGline
Overrides:
getValue in class PGobject
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 - 第一个点的坐标
y1 - 第一个点的坐标
x2 - 第二个点的坐标
y2 - 第二个点的坐标
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
转换失败时
Overrides:
setValue in class PGobject
public boolean equals(Object obj)
参数：
obj - 要比较的对象
返回值：
如果两个矩形相同则为 true
Overrides:
equals in class PGobject
public Object clone()
必须覆盖此方法才能克隆该对象
Overrides:
clone in class PGobject
public String getValue()
返回值：
按 PostgreSQL 所期望语法表示的 PGlseg
Overrides:
getValue in class PGobject
Class org.postgresql.geometric.PGpath
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.geometric.PGpath
public class PGpath extends PGobject implements Serializable,
Cloneable
它实现 path（一条多段线，可以是闭合的）
变量
public boolean open
如果路径是开放的则为 true，闭合则为 false
public PGpoint points[]
定义该路径的各个点
构造器
public PGpath(PGpoint points[],
boolean open)
参数：
points - 定义该路径的 PGpoint 数组
open - 如果路径是开放的则为 true，闭合则为 false
public PGpath()
驱动所需
public PGpath(String s) throws SQLException
参数：
s - PostgreSQL 语法的圆定义。
抛出：SQLException
转换失败时
方法
public void setValue(String s) throws SQLException
参数：
s - PostgreSQL 语法的路径定义
抛出：SQLException
转换失败时
Overrides:
setValue in class PGobject
public boolean equals(Object obj)
参数：
obj - 要比较的对象
返回值：
如果两个矩形相同则为 true
Overrides:
equals in class PGobject
public Object clone()
必须覆盖此方法才能克隆该对象
Overrides:
clone in class PGobject
public String getValue()
返回按 PostgreSQL 所期望语法表示的该多边形
Overrides:
getValue in class PGobject
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
转换失败时
Overrides:
setValue in class PGobject
public boolean equals(Object obj)
参数：
obj - 要比较的对象
返回值：
如果两个矩形相同则为 true
Overrides:
equals in class PGobject
public Object clone()
必须覆盖此方法才能克隆该对象
Overrides:
clone in class PGobject
public String getValue()
返回值：
按 PostgreSQL 所期望语法表示的 PGpoint
Overrides:
getValue in class PGobject
public void translate(int x,
int y)
按给定的量平移该点。
参数：
x - 在 x 轴上要加的整数增量
y - 在 y 轴上要加的整数增量
public void translate(double x,
double y)
按给定的量平移该点。
参数：
x - 在 x 轴上要加的 double 增量
y - 在 y 轴上要加的 double 增量
public void move(int x,
int y)
把该点移动到给定的坐标。
参数：
x - 整数坐标
y - 整数坐标
public void move(double x,
double y)
把该点移动到给定的坐标。
参数：
x - double 坐标
y - double 坐标
public void setLocation(int x,
int y)
把该点移动到给定的坐标。相关描述参见 java.awt.Point
参数：
x - 整数坐标
y - 整数坐标
参见：
Point
public void setLocation(Point p)
把该点移动到给定的 java.awt.Point。相关描述参见 java.awt.Point
参数：
p - 要移动到的点
参见：
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[]
定义该多边形的各个点
构造器
public PGpolygon(PGpoint points[])
用一个 PGpoint 数组创建多边形
参数：
points - 定义该多边形的各个点
public PGpolygon(String s) throws SQLException
参数：
s - PostgreSQL 语法的圆定义。
抛出：SQLException
转换失败时
public PGpolygon()
驱动所需
方法
public void setValue(String s) throws SQLException
参数：
s - PostgreSQL 语法的多边形定义
抛出：SQLException
转换失败时
Overrides:
setValue in class PGobject
public boolean equals(Object obj)
参数：
obj - 要比较的对象
返回值：
如果两个矩形相同则为 true
Overrides:
equals in class PGobject
public Object clone()
必须覆盖此方法才能克隆该对象
Overrides:
clone in class PGobject
public String getValue()
返回值：
按 PostgreSQL 所期望语法表示的 PGpolygon
Overrides:
getValue in class PGobject
大对象在标准的 JDBC 规范中受支持。但是，那个接口是 有限的，而 PostgreSQL 提供的 API 允许对对象内容进行随机 访问，就像它是一个本地文件一样。
org.postgresql.largeobject 包向 Java 提供了 libpq C 接口的大对象 API。它由两个类组成： LargeObjectManager 处理大对象的创建、 打开和删除，而 LargeObject 处理 单个对象。
org.postgresql.largeobject.LargeObject 类public class LargeObject extends Object java.lang.Object | +----org.postgresql.largeobject.LargeObject
这个类实现了到 PostgreSQL 的大对象接口。
它提供了运行该接口所需的基本方法，外加 为这个对象提供 InputStream 和 OutputStream 类的一对方法。
通常，客户端代码会使用 ResultSet 中的 getAsciiStream、getBinaryStream 或 getUnicodeStream 方法，或 PreparedStatement 中的 setAsciiStream、setBinaryStream 或 setUnicodeStream 方法来 访问大对象。
然而，有时需要对大对象进行更底层的访问，而这些是 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 void 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
从一个数组向该对象写入一些数据
参数：.
org.postgresql.largeobject.LargeObjectManager 类
public class LargeObjectManager extends Object
java.lang.Object
|
+----org.postgresql.largeobject.LargeObjectManager
这个类实现了到 PostgreSQL 的大对象接口。它提供的 方法允许客户端代码从数据库中创建、打开和删除 大对象。打开一个对象时，会返回一个 org.postgresql.largeobject.LargeObject 的 实例，然后它的方法就允许访问该对象。
这个类只能由 org.postgresql.Connection 创建。要 获得这个类的访问权，使用下面这段代码：
import org.postgresql.largeobject.*; Connection conn; LargeObjectManager lobj; // ... code that opens a connection ... lobj = ((org.postgresql.Connection)myconn).getLargeObjectAPI();
通常，客户端代码会使用 ResultSet 中的 getAsciiStream、getBinaryStream 或 getUnicodeStream 方法，或 PreparedStatement 中的 setAsciiStream、setBinaryStream 或 setUnicodeStream 方法来 访问大对象。但是，有时需要对 大对象进行更底层的访问，而这些是 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 方法完全相同，提供它是因为 C API 使用 “unlink”。
PostgreSQL 不是一个普通的 SQL 数据库。它比大多数其他数据库的可扩展性 更强，并且确实支持一些它独有的面向对象特性。
其中一个后果是，你可以让一个表引用另一个表中的一行。 例如：
test=> create table users (username name,fullname text);
CREATE
test=> create table server (servername name,adminuser users);
CREATE
test=> insert into users values ('peter','Peter Mount');
INSERT 2610132 1
test=> insert into server values ('maidast',2610132::users);
INSERT 2610133 1
test=> select * from users;
username|fullname
--------+--------------
peter |Peter Mount
(1 row)
test=> select * from server;
servername|adminuser
----------+---------
maidast | 2610132
(1 row)
好，上面的例子表明我们可以把一个表名用作字段，该行的 oid 值 就存储在那个字段中。
这与 Java 有什么关系？
在 Java 中，只要一个对象的类实现了 java.io.Serializable 接口， 你就可以把它存储到一个流。这一过程称为对象串行化 （Object Serialization），可以用来把复杂的对象存储到 数据库中。
现在，在 JDBC 下，你得用 大对象来存储它们。但是，你无法对这些对象执行查询。
org.postgresql.util.Serialize 类所做的，就是提供一种把对象 存储为一个表、以及从一个表取回该对象的手段。在大多数情况下， 你不需要直接访问这个类，而是使用 PreparedStatement.setObject() 和 ResultSet.getObject() 方法。这些方法会把对象的类名与数据库中 的表对照。如果找到匹配，它就假定该对象是一个串行化的对象， 并从那个表中取回它。在这样做时，如果该对象还包含其他串行化的 对象，它就会沿着树递归下去。
听起来很复杂？实际上，它比我写的还要简单 —— 只是难以解释 而已。
你唯一需要访问这个类的场合，是使用 create() 方法。驱动并不使用这些方法，它们根据你想要串行化的 Java 对象 或类，向数据库发出一条或多条 "create table" 语句。
哦，还有最后一件事。如果你的对象包含这样一行：
public int oid;
那么当该对象从表中取回时，它会被设为表中的 oid。 这样，如果该对象被修改并重新串行化，现有的条目就会被更新。
如果 oid 变量不存在，那么当该对象被串行化时，它总是会被插入 到表中，表中任何已有的条目都会保留。
在串行化之前把 oid 设为 0，也会导致该对象被插入。这使得 一个对象可以在数据库中被复制。
Class org.postgresql.util.Serialize
java.lang.Object
|
+----org.postgresql.util.Serialize
public class Serialize extends Object
这个类利用 PostgreSQL 的面向对象特性来存储 Java 对象。做法是把 Java 类名映射为数据库中的一个表。新表中的每个条目代表该类的一个序列化实例。由于每个条目都有一个 OID（对象标识符），这个 OID 可以被包含在另一个表中。这太复杂，不在此展示，主文档中会有更详细的说明。
构造器
public Serialize(Connection c,
String type) throws SQLException
它创建一个实例，可用于对 PostgreSQL 表中的 Java 对象做序列化/反序列化。
方法
public Object fetch(int oid) throws SQLException
它根据 OID 从表中取回一个对象
参数：
oid - 对象的 oid
返回值：
与 oid 对应的对象
抛出：SQLException
出错时
public int store(Object o) throws SQLException
它把一个对象存入表中并返回其 OID。
如果对象有一个名为 OID 的 int 且其值 > 0，就用该值作 OID，表将被更新。如果 OID 的值为 0，则会新建一行，并且 OID 的值会被设置到对象中。这使对象在数据库中的值可以更新。如果对象没有名为 OID 的 int，则直接存储对象。但若对象随后被取回、修改并再次存储，它的新状态会被追加到表中，而不会覆盖旧条目。
参数：
o - 要存储的对象（必须实现 Serializable）
返回值：
已存储对象的 oid
抛出：SQLException
出错时
public static void create(Connection con,
Object o) throws SQLException
驱动不使用此方法；它根据一个可序列化的 Java 对象创建表。应当在序列化任何对象之前使用它。
参数：
c - 到数据库的连接
o - 表所基于的对象
抛出：SQLException
出错时
返回值：
与 oid 对应的对象
抛出：SQLException
出错时
public int store(Object o) throws SQLException
它把一个对象存入表中并返回其 OID。
如果对象有一个名为 OID 的 int 且其值 > 0，就用该值作 OID，表将被更新。如果 OID 的值为 0，则会新建一行，并且 OID 的值会被设置到对象中。这使对象在数据库中的值可以更新。如果对象没有名为 OID 的 int，则直接存储对象。但若对象随后被取回、修改并再次存储，它的新状态会被追加到表中，而不会覆盖旧条目。
参数：
o - 要存储的对象（必须实现 Serializable）
返回值：
已存储对象的 oid
抛出：SQLException
出错时
public static void create(Connection con,
Object o) throws SQLException
驱动不使用此方法；它根据一个可序列化的 Java 对象创建表。应当在序列化任何对象之前使用它。
参数：
c - 到数据库的连接
o - 表所基于的对象
抛出：SQLException
出错时
public static void create(Connection con,
Class c) throws SQLException
驱动不使用此方法；它根据一个可序列化的 Java 对象创建表。应当在序列化任何对象之前使用它。
参数：
c - 到数据库的连接
o - 表所基于的类
抛出：SQLException
出错时
public static String toPostgreSQL(String name) throws SQLException
它把 . 替换为 _，从而把 Java 类名转换为 PostgreSQL 表名
因此，类名中不能含有 _。
另一个限制是，完整类名（含包名）不能超过 31 个字符（这是 PostgreSQL 强加的限制）。
参数：
name - 类名
返回值：
PostgreSQL 表名
抛出：SQLException
出错时
public static String toClassName(String name) throws SQLException
它把 _ 替换为 .，从而把 PostgreSQL 表名转换为 Java 类名
参数：
name - PostgreSQL 表名
返回值：
类名
抛出：SQLException
出错时
工具类
org.postgresql.util 包包含主驱动内部使用的类以及其他扩展使用的类。
Class org.postgresql.util.PGmoney
java.lang.Object
|
+----org.postgresql.util.PGobject
|
+----org.postgresql.util.PGmoney
public class PGmoney extends PGobject implements Serializable,
Cloneable
它实现一个处理 PostgreSQL money 类型的类
变量
public double val
字段的值
构造器
public PGmoney(double value)
参数：
value - 字段的值
public PGmoney(String value) throws SQLException
当某点嵌入其他几何类型的定义中时，主要由那些类型调用此构造器。
参数：
value - PostgreSQL 语法的该点定义
public PGmoney()
驱动所需
方法
public void setValue(String s) throws SQLException
参数：
s - PostgreSQL 语法的该点定义
抛出：SQLException
转换失败时
Overrides:
setValue in class PGobject
public boolean equals(Object obj)
参数：
obj - 要比较的对象
返回值：
如果两个矩形相同则为 true
Overrides:
equals in class PGobject
public Object clone()
必须覆盖此方法才能克隆该对象
Overrides:
clone in class PGobject
public String getValue()
返回值：
按 PostgreSQL 所期望语法表示的 PGpoint
Overrides:
getValue in class PGobject
Class org.postgresql.util.PGobject
java.lang.Object
|
+----org.postgresql.util.PGobject
public class PGobject extends Object implements Serializable,
Cloneable
这个类用于描述 JDBC 标准所不知道的数据类型。调用 org.postgresql.Connection 可以让一个继承本类的类与一个命名类型关联。org.postgresql.geometric 包就是这样工作的。对任何没有被认出有自己处理器的类型，ResultSet.getObject() 都会返回这个类。因此，任何 PostgreSQL 数据类型都得到支持。
构造器
public PGobject()
它由 org.postgresql.Connection.getObject() 调用来创建对象。
方法
public final void setType(String type)
此方法设置该对象的类型。
子类不应扩展它，因此它是 final 的
参数：
type - 描述该对象类型的字符串
public void setValue(String value) throws SQLException
此方法设置该对象的值。它必须被覆盖。
参数：
value - 对象值的字符串表示
抛出：SQLException
如果值对该类型无效则抛出
public final String getType()
由于它在对象生命周期内不能改变，因此是 final 的。
返回值：
该对象的类型名
public String getValue()
必须覆盖它，以 PostgreSQL 所要求的形式返回对象的值。
返回值：
该对象的值
public boolean equals(Object obj)
必须覆盖它才能比较对象
参数：
obj - 要比较的对象
返回值：
如果两个矩形相同则为 true
Overrides:
equals in class Object
public Object clone()
必须覆盖此方法才能克隆该对象
Overrides:
clone in class Object
public String toString()
这里已定义它，因此用户代码不必覆盖。
返回值：
按 PostgreSQL 所期望语法表示的该对象的值
Overrides:
toString in class Object
Class org.postgresql.util.PGtokenizer
java.lang.Object
|
+----org.postgresql.util.PGtokenizer
public class PGtokenizer extends Object
这个类用于对 PostgreSQL 的文本输出做分词。
本可以用 StringTokenizer 来做，但我们需要处理 '(' ')' '[' ']' '<' 和 '>' 的嵌套，几何数据类型会用到它们。
它主要由几何类使用，但对解析 PostgreSQL 自定义数据类型的任何输出也有用。
参见：
PGbox, PGcircle, PGlseg, PGpath, PGpoint, PGpolygon
构造器
public PGtokenizer(String string,
char delim)
创建一个分词器。
参数：
string - 包含各词的字符串
delim - 分割各词的单个字符
方法
public int tokenize(String string,
char delim)
用一个新字符串和/或新分隔符重置该分词器。
参数：
string - 包含各词的字符串
delim - 分割各词的单个字符
public int getSize()
返回值：
可用词的数量
public String getToken(int n)
参数：
n - 词的编号（0 ... getSize()-1）
返回值：
词的值
public PGtokenizer tokenizeToken(int n,
char delim)
它基于我们的某个词返回一个新的分词器。几何数据类型用它处理嵌套的词（通常是 PGpoint）。
参数：
n - 词的编号（0 ... getSize()-1）
delim - 要使用的分隔符
返回值：
基于该词的一个新 PGtokenizer 实例
public static String remove(String s,
String l,
String t)
移除一个字符串的前导/尾随字符串
参数：
s - 源字符串
l - 要移除的前导字符串
t - 要移除的尾随字符串
返回值：
不含前导/尾随字符串的字符串
public void remove(String l,
String t)
移除所有词的前导/尾随字符串
参数：
l - 要移除的前导字符串
t - 要移除的尾随字符串
public static String removePara(String s)
移除字符串开头和结尾的 ( 和 )
参数：
s - 要从中移除的字符串
返回值：
不含 ( 或 ) 的字符串
public void removePara()
移除所有词开头和结尾的 ( 和 )
返回值：
不含 ( 或 ) 的字符串
public static String removeBox(String s)
移除字符串开头和结尾的 [ 和 ]
参数：
s - 要从中移除的字符串
返回值：
不含 [ 或 ] 的字符串
public void removeBox()
移除所有词开头和结尾的 [ 和 ]
返回值：
不含 [ 或 ] 的字符串
public static String removeAngle(String s)
移除字符串开头和结尾的 < 和 >
参数：
s - 要从中移除的字符串
返回值：
不含 < 或 > 的字符串
public void removeAngle()
移除所有词开头和结尾的 < 和 >
返回值：
不含 < 或 > 的字符串
Class org.postgresql.util.Serialize
它已在前面“对象序列化”一节中说明。
Class org.postgresql.util.UnixCrypt
java.lang.Object
|
+----org.postgresql.util.UnixCrypt
public class UnixCrypt extends Object
这个类使我们能够在口令经网络流发送时对其加密
包含用于加密口令以及与 Unix 加密口令比对的静态方法。
原始源码见 John Dumas 的 Java Crypt 页面。
http://www.zeh.com/local/jfd/crypt.html
方法
public static final String crypt(String salt,
String original)
根据明文口令和一个“盐”加密口令。
参数：
salt - 一个两字符字符串，表示用于以多种方式迭代加密引擎的盐。如果要生成新加密，此值应当随机化。
original - 要加密的口令。
返回值：
由 2 字符盐后接加密口令组成的字符串。
public static final String crypt(String original)
根据明文口令加密口令。此方法用 'java.util.Random' 类生成随机盐。
参数：
original - 要加密的口令。
返回值：
由 2 字符盐后接加密口令组成的字符串。
public static final boolean matches(String encryptedPassword,
String enteredPassword)
检查 enteredPassword 加密后是否等于 encryptedPassword。
参数：
encryptedPassword - 已加密口令。假定前两个字符是盐。该字符串与 Unix /etc/passwd 文件中的形式相同。 enteredPassword - 用户（或其他途径）输入的口令。
返回值：
如果口令应视为正确则为 true。
译文有误、术语不当或页面显示问题，请到译文仓库 pgsty/pgdoc 报告译文问题。 英文原文本身的问题，请在当前版本的对应页面向上游反馈；上游不再修订已结束维护的版本。