PostgreSQL7.0手冊-接口-58. JDBC 接口

2019-09-08 23:34:10

字體：大中小

來源：轉載

供稿：網友

第五十八章.　JDBC　接口
內容　
制作　JDBC　接口　
為　JDBC準備數據庫　
使用驅動　
裝入　JDBC　
裝載驅動　
與數據庫聯接　
發出查詢和處理結果　
執行更新　
關閉聯接　
使用大對象　
Postgres　對　JDBC　API的擴展　
深入閱讀　
作者：由　Peter　T.　Mount　執筆，他是JDBC　驅動的作者．
JDBC　是　Java　1.1　及以后的核心　API．它為　SQL　兼容的數據庫提供了一個標準的接口集合．　
Postgres　提供了類型　4JDBC　驅動．類型　4　表明該驅動是用純　Java　書寫的，并且與數據庫之間使用數據庫自己的網絡協議通訊．因此，驅動是平臺無關的．一旦編譯，該驅動可以用于任意平臺．　

制作　JDBC　接口
編譯驅動
驅動的源代碼位于源碼樹的　src/interfaces/jdbc　目錄．要編譯之，你只需要進入該目錄，然后鍵入：　
%　make
編譯完成后，你將在當前目錄發現文件　postgresql.jar．這就是　JDBC　驅動．　
　　
注意：你必須使用　make，而不是　javac，因為驅動因為性能原因使用了一些動態聯接技巧，這些是　javac　辦不到的．Makefile　將生成　jar　歸檔文件．
安裝驅動
要使用驅動，.jar　文件　postgresql.jar　需要被包含在　CLASSPATH　里．　
例子
我有一個使用　JDBC　驅動的應用，該應用訪問一個包含天文對象的大數據庫．我已經有這個應用并且　jdbc　驅動安裝在　/usr/local/lib　目錄，并且　java　jdk　安裝在　/usr/local/jdk1.1.6．　
要運行應用，我可以用：　

export　CLASSPATH　=　/usr/local/lib/finder.jar:/usr/local/lib/postgresql.jar:.
java　uk.org.retep.finder.Main
裝載驅動在本章后面部分介紹．

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

為　JDBC　準備數據庫
因為　Java　只能使用　TCP/IP　聯接，Postgres　的　postmaster　必須帶　-i　參數運行．　
同樣，必須配置　pg_hba.conf　文件．它放在　PGDATA　目錄．缺省安裝時，這個文件只允許　UNIX　域套接字訪問．對聯到同樣　localhost　的JDBC　驅動（應用），你需要加一些象：　

host　　　　　　　　　all　　　　　　　　　127.0.0.1　　　　　255.255.255.255　　　password
的東西（到　pg_hba.conf　文件），這里允許從本地　JDBC　對所有數據庫的訪問．　
JDBC　驅動支持　trust，ident，password　和　crypt　認證模式．

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

使用驅動
本章并不想作為完整的　JDBC　編程的指導，但應該能幫你走出第一步．更多信息請參考標準　JDBCAPI　文檔．同樣，讀一下包含在源代碼里的例子．其中的基本例子在這里使用．

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

裝入　JDBC
任何使用　JDBC　的程序需要輸入　java.sql　包，用：　
import　java.sql.*;
關鍵：不要輸入　postgresql　包．如果這樣做，你的源碼將不能編譯，因為　javac　會被你搞糊涂。

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

裝載驅動
在你試圖與數據庫連接之前，你需要裝載驅動．有兩種方法，那種更好取決于你使用的代碼．　
在第一種方法里，你的代碼用　Class.forName()　方法顯式裝載驅動．對于　Postgres，你要用：　

Class.forName("postgresql.Driver");
這樣將裝載驅動，并且在裝載時，驅動將自動與　JDBC　注冊自己．　
注意：forName()　方法可以拋出一個　ClassNotFoundException，所以如果驅動不可獲得時你需要捕獲它．　

這是最常用的方法，但是把你的代碼限制于　Postgres　專用．如果你的代碼以后還要訪問其他數據庫，并且你不想使用我們的擴展，那么第二種方法可用．　

第二種方法把驅動做為參數在　JVM　啟動時傳遞給它，使用　-D　參數．　

%　java　-Djdbc.drivers=postgresql.Driver　example.ImageViewer
在這個例子里，JVM　將試圖把驅動作為它的初始化的一部分裝載．一旦完成，啟動　ImageViewer。　
現在，這個方法是一個更好的手段，因為它允許你的代碼用于其他數據庫，而不用重新編譯代碼．唯一要修改的東西是　URL，我們下面要提到．　

最后一件事情．當你的代碼試圖打開一個聯接，而且你收到一個拋出的　No　driver　available　SQLException　例外，這可能是因為驅動不在　classpath　（類路徑）里，或者參數值不正確．

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

與數據庫聯接
在　JDBC　里，數據庫是用　URL　（Uniform　Resource　Locator）（統一資源定位器）表示的．在　Postgres　里，這可以由下面幾種格式之一表示：　
jdbc:postgresql:database　
jdbc:postgresql://host/database　

jdbc:postgresql://hostport/database

這里：　
　　
host　
服務器的主機名．缺省是　"localhost"．　
port　
服務器監聽的端口號．缺省時是　Postgres　標準的端口號（5432）．　
database　
數據庫名．　
要聯接（數據庫），你需要從　JDBC　獲取一個聯接實例（Connection　instance）．要做這些，你要使用　DriverManager.getConnection()　方法：　
Connection　db　=　DriverManager.getConnection(url,user,pwd);

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

發出查詢和處理結果
在任何你想向數據庫運行一個　SQL　語句的時候，你都需要一個　Statement　（語句）實例．一旦你擁有了一個　Statement　（語句），你就可以使用　executeQuery()　方法來運行一個查詢．這樣將返回一個　ResultSet　實例，在其內部包含整個結果．　
使用　Statement　（語句）接口
在使用　Statement　接口時必須考慮下面的問題：　
你可以使用一個　Statement　（語句）實例任意次．你可以在打開一個聯接后馬上創建一個　Statement　（語句）實例，并且在聯接的生存期里使用之．你必須知道每個　Statement　只能存在一個　ResultSet　（結果集）．　
如果你需要在處理一個　ResultSet　的時候執行一個查詢，你只需要創建并且使用另外一個　Statement．　

如果你使用了　Threads　（線程），并且有幾個使用數據庫，你對每個線程必須使用一個獨立的　Statement．如果考慮使用線程，請參考本文檔稍后描述　Threads　和　Servlets　的章節，因為這些內容包含一些重要的信息．

使用　ResultSet　（結果集）接口
使用　ResultSet　接口時必須考慮下面的問題：　
在讀取任何數值的時候，你必須調用　next()．如果還有結果則返回真（true），但更重要的是，它為處理準備了數據行．　
在　JDBC　規范里，你應該對一個字段只訪問一次．遵循這個規則是安全的，不過目前　Postgres　驅動將允許你對一個字段訪問任意次．　

一旦你結束對一個　ResultSet　的處理，你必須調用對之　close()。　

一旦你使用那個創建　ResultSet　的　Statement　做另一個查詢請求，當前打開的實例將被關閉．

下面是一個例子：　
Statement　st　=　db.createStatement();
ResultSet　rs　=　st.executeQuery("select　*　from　mytable");
while(rs.next())　{
　　　　System.out.print("Column　1　returned　");
　　　　System.out.println(rs.getString(1));
}
rs.close();
st.close();

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

執行更新
要執行一次更新　（或任何其他不返回結果的　SQL　語句），你只需要使用　executeUpdate()　方法：　
st.executeUpdate("create　table　basic　(a　int2,　b　int2)");

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

關閉聯接
要關閉數據庫聯接，只需要對聯接調用　close()　方法：　
db.close();

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

使用大對象
在　Postgres　里，大對象（也稱之為　液滴(blobs)　）用于保存那些無法在通常　SQL　表里面保存的數據．它們是通過表/索引對進行存儲的，然后用一個　OID　值從你自己的表里面引用．　
關鍵：對于　Postgres，你必須在一個　SQL　事務里面訪問大對象。盡管我們總是這樣要求，但直到版本　6.5　我們才嚴格要求這樣做。你應該帶著一個輸入參數　false　使用　setAutoCommit()　方法打開一個事務：　
Connection　mycon;
...
mycon.setAutoCommit(false);
...　now　use　Large　Objects
現在，你有幾種使用大對象的方法．第一種是標準的　JDBC　方式，這個方式在這里有文檔．另一種，使用我們對該（JDBC）api　（編程接口）的擴展，也是一種用于　Java　的　libpq　大對象　API　的形式，提供了一種比標準方法更好的訪問大對象的訪問方法．在系統內部，該驅動使用這種擴展來提供大對象支持．　
在JDBC里，標準的訪問大對象的方法是使用　ResultSet　里的　getBinaryStream()　方法，和PreparedStatement　里的　setBinaryStream()　方法．這些方法把大對象表示成　Java　的流（stream），允許你用　java.io　和其他的包來操縱這些對象．　

例如，假設你有一個包含一幅圖象文件名的表，而且一個大對象包含這個圖象：　

create　table　images　(imgname　name,imgoid　oid);
要插入一幅圖象，你可以：　
File　file　=　new　File("myimage.gif");
FileInputStream　fis　=　new　FileInputStream(file);
PreparedStatement　ps　=　conn.prepareStatement("insert　into　images　values　(?,?)");
ps.setString(1,file.getName());
ps.setBinaryStream(2,fis,file.length());
ps.executeUpdate();
ps.close();
fis.close();
現在，在這個例子里，setBinaryStream　從一個流里面把一定字節的數據轉換到大對象里，然后把（大對象的）　OID　存儲到引用它的字段里．　
檢索一幅圖象甚至更快（我在這里使用　PreparedStatement　，當然用　Statement　也是一樣的）：　

PreparedStatement　ps　=　con.prepareStatement("select　oid　from　images　where　name=?");
ps.setString(1,"myimage.gif");
ResultSet　rs　=　ps.executeQuery();
if(rs!=null)　{
　　　　while(rs.next())　{
　　　　　　　　InputStream　is　=　rs.getBinaryInputStream(1);
　　　　　　　　//　use　the　stream　in　some　way　here
　　　　　　　　is.close();
　　　　}
　　　　rs.close();
}
ps.close();
這里你可以看到這里大對象是當做一個　InputStream　（輸入流）檢索的．你還會注意到我們在處理結果的下一行之前關閉了流．這是　JDBC　規范的一部分，該規范指出任何返回的　InputStream　在調用　ResultSet.next()　或　ResultSet.close()　后都要被關閉．

--------------------------------------------------------------------------------
--------------------------------------------------------------------------------

Postgres　對　JDBC　API的擴展
Postgres　是一種可擴展的數據庫系統．你可以向數據庫后端里增加你自己的函數，這些函數可以供查詢調用，甚至你可以增加你自己的數據類型．　
因為目前這些特性是我們獨有的，所以我們在　Java　里通過一套擴展的　API　提供對這些特性的支持．在標準驅動的核心里有些特性實際上是通過這些擴展實現的，比如大對象等．　

獲得這些擴展

要獲得某些擴展，你需要使用　postgresql.Connection　類里的一些額外的方法
這時，你需要轉換　　Driver.getConnection()　的返回值．

例如：

　　　　Connection　db　=　Driver.getConnection(url,user,pass);

　　　　//　later　on
　　　　Fastpath　fp　=　((postgresql.Connection)db).getFastpathAPI();

Class　postgresql.Connection
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
java.lang.Object
　　　|
　　　+----postgresql.Connection

　　　公共類　(public　class)　Connection　擴展了(類)　Object　實現的　Connection

這些是用于獲取我們的擴展的額外方法．我
沒有列出由　java.sql.Connection　定義的方法．

　public　Fastpath　getFastpathAPI()　throws　SQLException

　　　　　　　　　　這里返回當前聯接的　Fastpath　API．

　　　　　　　　　　注意：這個用法不是　JDBC　的一部分，但是允許使用　postgresql　后端本身的函數．

　　　　　　　　　　這個用法基本上是用于　LargeObject　API　的

　　　　　　　　　　使用這個用法的最好的方法是：

　import　postgresql.fastpath.*;
　...
　Fastpath　fp　=　((postgresql.Connection)myconn).getFastpathAPI();

　　　　　　　　　　　這里　myconn　是一個打開了的到　postgresql　的　Connection　（聯接）．

　　　　　　　　返回：
　　　　　　　　　　　　　　　　Fastpath　對象允許使用在　postgresql　后端上的函數．

　　　　　　　　拋出：　SQLException
　　　　　　　　　　　　　　　　在　Fastpath　為第一次使用初始化時生成
　　　　　　　　　　
　public　LargeObjectManager　getLargeObjectAPI()　throws　SQLException

　　　　　　　　　　這個語句為當前聯接返回　LargeObject　API．

　　　　　　　　　　注意：這個用法不是　JDBC　的一部分，但是允許使用　postgresql　后端本身的函數．
　　　
　　　　　　　　　　使用這個用法的最好的方法是：

　import　postgresql.largeobject.*;
　...
　LargeObjectManager　lo　=　
((postgresql.Connection)myconn).getLargeObjectAPI();

　　　　　　　　　　這里　myconn　是一個打開了的到　postgresql　的　Connection　（聯接）．

　　　　　　　　返回：
　　　　　　　　　　　　　　　　實現該　API　的　LargeObject　對象

　　　　　　　　拋出：　SQLException
　　　　　　　　　　　　　　　　在　LargeObject　為第一次使用初始化時生成

　public　void　addDataType(String　type,
　　　　　　　　　　　　　　　　　　　　　　　　　String　name)

　　　　　　　　　　這個函數允許客戶應用代碼為　postgresql　眾多獨立數據類型的一個增加一個控制器．
通常，驅動器不能識別的數據類型由　ResultSet.getObject()　做為　PGobject　實例返回．

這個方法允許你寫一個類擴展　PGobject，并且　
告訴驅動器要使用的類型名稱和類名稱．

這樣做的不便之處是你每次進行聯接后都必須調用這個方法.

　　　　　　　　　　注意：這個用法不是　JDBC　的一部分,　而是一個擴展．

　　　　　　　　　　使用這個用法的最好方法是：

　...
　((postgresql.Connection)myconn).addDataType("mytype","my.class.name"-
);
　...

　　　　　　　　　　這里　myconn　是一個打開了的與　postgresql　的　Connection　（聯接）．

　　　　　　　　　　該控制類必須擴展　postgresql.util.PGobject

　　　　　　　　參閱：
　　　　　　　　　　　　　　　　PGobject

Fastpath

Fastpath　是一套存在于libpq　C　接口里的API，并且這個接口允許客戶機器執行后端數據庫的函數.
大多數客戶端代碼不需要使用這個方法，但是我們還是提供這個方法，因為大對象　API　使用它．

要使用這個特性，你需要輸入　postgresql.fastpath　包，使用下面行
　　　　　import　postgresql.fastpath.*;

然后，在你的代碼里，你需要獲取一個　FastPath　對象：
　　　　　Fastpath　fp　=　((postgresql.Connection)conn).getFastpathAPI();

這樣將返回一個實例，該實例與你用來執行命令的數據庫聯接相關聯．
把　Connection　轉換成　postgresql.Connection　是必須的，因為　getFastpathAPI()　是我們自己的
方法之一，而不是　JDBC　的．

一旦你有一個　Fastpath　實例，你就可以使用　fastpath()　方法來執行后端函數.

Class　postgresql.fastpath.Fastpath

java.lang.Object
　　　|
　　　+----postgresql.fastpath.Fastpath

　　　公共類　(public　class)　Fastpath

　　　擴展了　Object

　　　這個類實現了　Fastpath　api　（編程接口）．

　　　這是在一個　java　應用里執行內嵌在　postgresql　后端的函數的方法．

　　　這個方法是以文件　src/interfaces/libpq/fe-exec.c　為基礎的

　　　參閱：
　　　　　　　　　　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[]
　　　　　　　　　
　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了一個數據庫訪問錯誤.

　public　Object　fastpath(String　name,
　　　　　　　　　　　　　　　　　　　　　　　　boolean　resulttype,
　　　　　　　　　　　　　　　　　　　　　　　　FastpathArg　args[])　throws　SQLException

　　　　　　　　　通過名稱向　PostgreSQL　后端發送一個函數調用.

注意:
　　　　　　　　　函數名到函數　id　的影射必須存在,　通常先調用　addfunction().　這是調用函數的比較好的方法,
因為函數　id　在不同版本的后端里是會/可能改變的.　獲取這個方法工作的例子,　參閱　postgresql.LargeObject

　　　　　　　　參數:
　　　　　　　　　　　　　　　　name　-　函數名稱
　　　　　　　　　　　　　　　　resulttype　-　如果結果是整數返回真　(true),　其他結果返回假　(false)
　　　　　　　　　　　　　　　　args　-　傳遞給　fastpath　的參數　FastpathArguments

　　　　　　　　返回:
　　　　　　　　　　　　　　　　如果沒有數據返回空　(null),　如果結果為整數返回一個　Integer,　否則返回　byte[]

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果名稱未知或者數據庫訪問錯誤發生.

　　　　　　　　參閱:
　　　　　　　　　　　　　　　　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　是靜態的,　甚至運行在不同服務器的同版本的數據庫也不能保證是統一的.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　name　-　函數名
　　　　　　　　　　　　　　　　fnid　-　函數　id

　public　void　addFunctions(ResultSet　rs)　throws　SQLException
　　　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　這個方法接收一個包含兩個字段的　ResultSet.　字段　1　包含函數名,　字段　2　是　oid.

　　　　　　　　　　它讀取整個　ResultSet,　把值裝載入函數表.

　　　　　　　　　　調用完這個方法后記得用　close()　關閉結果集!!

　　　　　　　　　　關于函數名查找實現的信息:
　　　　　　　　　　
　　　　　　　　　　PostgreSQL　在　pg_proc　表里存儲函數　id　和它們對應的名稱,　在
查找時不是從該表里查詢每個所需函數的名稱,　而是使用了一個　Hashtable　(散列表).
同樣,　只有需要的函數的名稱才放到這個表里,　以保證連接速度盡可能快.

　　　　　　　　　　postgresql.LargeObject　類在啟動時執行一個查詢,　并且把返回的
　ResultSet　傳遞給這里提到的　addFunctions()　方法
　　　　　　　
　　　　　　　　　　一旦這些工作完成,　LargeObject　api　用名稱引用函數.
　　　　　　　　　　
　　　　　　　　　　不要以為手工把它們轉換成　oid　可以工作.　的確,　目前這樣做是可以用的,　但隨著開發的
過程這些可能被修改(在　V7.0　版本的討論中有一些關于這些的話題),　所以這樣做是防止未來將出現的
任何沒有保證的痛苦的手段.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　rs　-　ResultSet

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤.
　　　　　　　　　　
　　　　　　　　參閱:
　　　　　　　　　　　　　　　　LargeObjectManager

　public　int　getID(String　name)　throws　SQLException
　　　　　　　　　　
　　　　　　　　　　這個方法返回與函數名關聯的函數　id
　　　　　　　　　　
　　　　　　　　　　如果還沒有對這個函數調用　addFunction()　或　addFunctions(),　那么拋出一個　SQLException　.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　name　-　待查找的函數名

　　　　　　　　返回:
　　　　　　　　　　　　　　　　用于　fastpath　調用的函數　ID

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果函數未知.

Class　postgresql.fastpath.FastpathArg

java.lang.Object
　　　|
　　　+----postgresql.fastpath.FastpathArg

　　　public　class　FastpathArg　extends　Object
　　　　　　　　
　　　每個　fastpath　調用需要一個參數列表,　其數目和類型取決于被調用的函數.

　　　這個類實現了提供這個功能所需要的方法.

　　　關于如何使用這個方法的例子,　參閱postgresql.largeobject　包

　　　參閱:
　　　　　　　　　　Fastpath,　LargeObjectManager,　LargeObject

構造(方法)

　public　FastpathArg(int　value)
　
　　　　　　　　　　構造一個包含一個整數的參數

　　　　　　　　參數:
　　　　　　　　　　　　　　　　value　-　待設置的　int　(整數)值

　public　FastpathArg(byte　bytes[])
　　　　　　　　　　
　　　　　　　　　　構造一個包含一些字節的數組的參數

　　　　　　　　參數:
　　　　　　　　　　　　　　　　bytes　-　要保存的數組
　public　FastpathArg(byte　buf[],
　　　　　　　　　　　　　　　　　　　　int　off,
　　　　　　　　　　　　　　　　　　　　int　len)

　　　　　　　　　　　構造一個包含一個數組的一部分的參數

　　　　　　　　參數:
　　　　　　　　　　　　　　　　buf　-　源數組
　　　　　　　　　　　　　　　　off　-　數組內的偏移量
　　　　　　　　　　　　　　　　len　-　要包括的數據的長度

　public　FastpathArg(String　s)
　　　　　　　　　　
　　　　　　　　　　構造一個包含一個字符串的參數.
　　　　　　
　　　　　　　　參數:
　　　　　　　　　　　　　　　　s　-　要保存的字符串

幾何數據類型

PostgreSQL　有一個往表里存儲幾何特性的數據類型集.范圍包括點,　線,　和多邊形.

我們通過　postgresql.geometric　包來在　Java　里支持這些類型.

它包括擴展　postgresql.util.PGobject　類的類.參考該類獲取如何實現你自己的數據類型的控制器的細節.

Class　postgresql.geometric.PGbox

java.lang.Object
　　　|
　　　+----postgresql.util.PGobject
　　　　　　　　　　　|
　　　　　　　　　　　+----postgresql.geometric.PGbox

　　　公共類　PGbox　擴展　PGobject　實現　Serializable,　Cloneable

　　　這個類在　postgresql　里表示盒子　(box)　數據類型.

變量　(Variables)

　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　里的　clone　
　　　
　public　String　getValue()
　　　　　　　　
　　　　　　　　返回:
　　　　　　　　　　　　　　　　postgresql　需要的　PGbox　句法字串

　　　　　　　　重載:
　　　　　　　　　　　　　　　　PGobject　里的　getValue　
Class　postgresql.geometric.PGcircle

java.lang.Object
　　　|
　　　+----postgresql.util.PGobject
　　　　　　　　　　　|
　　　　　　　　　　　+----postgresql.geometric.PGcircle
　　　　　　　　
　　　　　　　
　　　公共類　PGcircle　擴展　PGobject　實現的　Serializable,　Cloneable
　　　　　　　　　　　　　　　
　　　這個類代表　postgresql　的圓數據類型,　由一個點和一個半徑組成

變量

　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
　　　　　　　　　　　　　　　　如果轉換失敗

　　　　　　　　重載:
　　　　　　　　　　　　　　　　類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　postgresql.geometric.PGline

java.lang.Object
　　　|
　　　+----postgresql.util.PGobject
　　　　　　　　　　　|
　　　　　　　　　　　+----postgresql.geometric.PGline

　　　公共類　PGline　擴展　PGobject　實現的　Serializable,　Cloneable

　　　這個類實現由兩個點組成的線.　目前線還沒有在后端實現,但這個類保證在后端實現后即可使用(線).

變量
　　　
　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
　　　　　　　　　　　　　　　　當發生轉換錯誤時

　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　setValue　
　　　　　　　　　　　　　　　　
　public　boolean　equals(Object　obj)

　　　　　　　　參數:
　　　　　　　　　　　　　　　　obj　-　要比較的對象
　　　　　　　　　　　　　　　
　　　　　　　　返回:
　　　　　　　　　　　　　　　　如果兩條線段相同返回真　(true)
　　　
　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　equals　

　public　Object　clone()
　　　　　　　　
　　　　　　　　　　　這個方法必須被重載以便允許這個對象可以被克隆

　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　clone　

　public　String　getValue()
　　　
　　　　　　　返回:
　　　　　　　　　　　　　　　　postgresql　語法要求的　PGline　字串
　　　　　　　　
　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　getValue　
Class　postgresql.geometric.PGlseg
　　　　　　　　　　　　　
java.lang.Object
　　　|
　　　+----postgresql.util.PGobject
　　　　　　　　　　　|
　　　　　　　　　　　+----postgresql.geometric.PGlseg
　　　　　　　　　　
　　　公共類　PGlseg　擴展　PGobject　實現的　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
　　　　　　　　　　　　　　　　在發生轉換錯誤時
　　　　　
　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　setValue　
　　　　　　　　　　　　　　　　
　public　boolean　equals(Object　obj)

　　　　　　　　參數:
　　　　　　　　　　　　　　　　obj　-　要比較的對象
　　　　　　　　　　　　　　　
　　　　　　　　返回:
　　　　　　　　　　　　　　　　如果兩條線段相等
　　　
　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　equals
　　　
　public　Object　clone()

　　　　　　　　　　必須重載這個方法以便允許這個對象被克隆

　　　　　　　　重載:
　　　　　　　　　　　　　　　類　PGobject　里的　clone

　public　String　getValue()

　　　　　　　　返回:
　　　　　　　　　　　　　　　　postgresql　語法要求的　PGlseg　字串
　　　　　　　　
　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　getValue

Class　postgresql.geometric.PGpath
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
java.lang.Object
　　　|
　　　+----postgresql.util.PGobject
　　　　　　　　　　　|
　　　　　　　　　　　+----postgresql.geometric.PGpath
　　　　　　　　　　
　　　公共類　PGpath　擴展　PGobject　實現　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()

　　　　　　　　　　必須重載這個方法以便允許這個對象被克隆

　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　clone

　public　String　getValue()

　　　　　　　　　　這個方法返回　postgresql　語法的多邊形字串

　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　getValue

　public　boolean　isOpen()

　　　　　如果路徑是開放的這個方法返回真　(true)

　public　boolean　isClosed()

　　　　　如果路徑是封閉的這個方法返回真　(true)

　public　void　closePath()

　　　　　標記路徑為封閉

　public　void　openPath()

　　　　　標記路徑為開放

Class　postgresql.geometric.PGpoint
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
java.lang.Object
　　　|
　　　+----postgresql.util.PGobject
　　　　　　　　　　　|
　　　　　　　　　　　+----postgresql.geometric.PGpoint
　　　　　　　　　　
　　　公共類　PGpoint　擴展　PGobject　實現　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　postgresql.geometric.PGpolygon
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
java.lang.Object
　　　|
　　　+----postgresql.util.PGobject
　　　　　　　　　　　|
　　　　　　　　　　　+----postgresql.geometric.PGpolygon

　　　公共類　PGpolygon　擴展　PGobject　實現　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
允許對對象內容的隨機訪問,　就象那是一個本地文件一樣.

postgresql.largeobject　包為　Java　提供了　libpq　C　接口的大對象　API.　它包含兩個類,　
LargeObjectManager,　處理創建,　打開和刪除大對象的任務,　以及　LargeObject,　處理獨立的對象.

Class　postgresql.largeobject.LargeObject

java.lang.Object
　　　|
　　　+----postgresql.largeobject.LargeObject

公共類　LargeObject　擴展　Object

這個類實現　postgresql　的大對象接口.

　　　它提供運行接口的基本的方法,　另外還有一對方法為此對象提供　InputStream　和　OutputStream　類.

　　　通常,　客戶代碼將在　ResultSet　里使用　getAsciiStream,　getBinaryStream,　
或　getUnicodeStream　方法,　或在訪問大對象　PreparedStatement　時用
setAsciiStream,　setBinaryStream,　或　setUnicodeStream　方法.

　　　但是,　有時候需要低層次的大對象訪問方法,那是　JDBC　規范還不支持的.

　　　參考　postgresql.largeobject.LargeObjectManager　獲取如何訪問大對象和如何創建大對象的信息.

　　　參閱:
　　　　　　　　　　LargeObjectManager

變量

　public　static　final　int　SEEK_SET

　　　　　　　　　　標識從一個文件的開頭進行一次搜索

　public　static　final　int　SEEK_CUR

　　　　　　　　　　標識從當前位置進行一次搜索

　public　static　final　int　SEEK_END

　　　　　　　　　　標識從一個文件的結尾進行一次搜索

方法

　public　int　getOID()

　　　　　　　　返回:
　　　　　　　　　　　　　　　　此大對象的　OID　

　public　void　close()　throws　SQLException

　　　　　　　　　　這個方法關閉對象.　在調用這個方法后你不能調用這個對象里的任何方法.

　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　byte[]　read(int　len)　throws　SQLException

　　　　　　　　　　從對象讀取一些數據,　并且做為　byte[]　數組返回

　　　　　　　　參數:
　　　　　　　　　　　　　　　　len　-　讀取的字節數

　　　　　　　　返回:
　　　　　　　　　　　　　　　　包含讀取數據的　byte[]　數組

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　void　read(byte　buf[],
　　　　　　　　　　　　　　　　　　int　off,
　　　　　　　　　　　　　　　　　　int　len)　throws　SQLException

　　　　　　　　　　從對象讀取一些數據到現有數組

　　　　　　　　參數:
　　　　　　　　　　　　　　　　buf　-　目的數組
　　　　　　　　　　　　　　　　off　-　數組內偏移量
　　　　　　　　　　　　　　　　len　-　讀取的字節數

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　void　write(byte　buf[])　throws　SQLException

　　　　　　　　　　向對象里寫入一個數組

　　　　　　　　參數:
　　　　　　　　　　　　　　　　buf　-　待寫數組

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　void　write(byte　buf[],
　　　　　　　　　　　　　　　　　　　int　off,
　　　　　　　　　　　　　　　　　　　int　len)　throws　SQLException

　　　　　　　　　　從數組里寫一些數據到對象

　　　　　　　　參數:
　　　　　　　　　　　　　　　　buf　-　目標數組
　　　　　　　　　　　　　　　　off　-　數組內偏移量
　　　　　　　　　　　　　　　　len　-　寫入字節數

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　void　seek(int　pos,
　　　　　　　　　　　　　　　　　　int　ref)　throws　SQLException

　　　　　　　　　　在對象內部設置當前位置.

　　　　　　　　　　這個類似于標準　C　庫里的　fseek()　調用它允許你對大對象進行隨機訪問.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　pos　-　對象內部的位置
　　　　　　　　　　　　　　　　ref　-　可以是　SEEK_SET,　SEEK_CUR　或　SEEK_END
　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　void　seek(int　pos)　throws　SQLException

　　　　　　　　　　在對象內部設置當前位置.

　　　　　　　　　　這個類似于標準　C　庫里的　fseek()　調用它允許你對大對象進行隨機訪問.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　pos　-　對象內部相對開頭的位置

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　int　tell()　throws　SQLException

　　　　　　　　返回:
　　　　　　　　　　　　　　　　對象內部當前位置

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　int　size()　throws　SQLException

　　　　　　　　　　這個方法不夠高效,　因為找出一個對象的唯一方法是搜索到結尾,　記錄當前位置,然后返回到初始位置.

　　　　　　　　　　今后要找出一個更好的方法.

　　　　　　　　返回:
　　　　　　　　　　　　　　　　大對象的尺寸

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　InputStream　getInputStream()　throws　SQLException

　　　　　　　　　　從對象返回一個　InputStream.

　　　　　　　　　　然后這個　InputStream　就可以用于任何需要一個　InputStream　的方法里.

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

　public　OutputStream　getOutputStream()　throws　SQLException

　　　　　　　　　　返回一個這個對象的　OutputStream

　　　　　　　　　　然后這個　OutputStream　就可以用于任何需要一個　OutputStream　的方法里.

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　如果發生了數據庫訪問錯誤

Class　postgresql.largeobject.LargeObjectManager
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
java.lang.Object
　　　|
　　　+----postgresql.largeobject.LargeObjectManager

公共類　LargeObjectManager　擴展　Object

這個類型實現　postgresql　的大對象接口.
　　　　　　　　
　　　它提供了允許客戶代碼從數據庫里創建,　打開和刪除大對象的方法.在打開一個對象時,　返回一個
postgresql.largeobject.LargeObject　的實例,　并且它的方法允許訪問該對象.

這個類只能由　postgresql.Connection　創建

要訪問這個類,　使用下面的代碼片段:

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

通常,　客戶代碼會在　ResultSet　里使用　getAsciiStream,　getBinaryStream,　
或　getUnicodeStream　方法,　或在訪問大對象的　PreparedStatement　里使用　setAsciiStream,　
setBinaryStream,　或　setUnicodeStream　方法.

　　　但是,　有時候需要低層次的大對象訪問方法,那是　JDBC　規范還不支持的.

　　　請參考　postgresql.largeobject.LargeObject　獲取如何控制大對象內容的信息.

　　　參閱:
　　　　　　　　　　LargeObject

變量

　public　static　final　int　WRITE

　　　　　　　　　　這個模式表明我們要寫入大對象

　public　static　final　int　READ

　　　　　　　　　　這個模式表明我們要讀取大對象

　public　static　final　int　READWRITE

　　　　　　　　　　這個模式是缺省的,　表明我們要對大對象進行讀和寫的操作

方法

　public　LargeObject　open(int　oid)　throws　SQLException
　　　　　　　　　　
　　　　　　　　　　這個方法打開一個現有的大對象,　以其　OID　為基礎.　這個方法假設
　　　　　　　　　　我們需要　READ　和　WRITE　訪問模式　(缺省模式).

　　　　　　　　參數:
　　　　　　　　　　　　　　　　oid　-　大對象標識　(oid)

　　　　　　　　返回:
　　　　　　　　　　　　　　　　提供訪問大對象的方法的　LargeObject　實例

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時

　public　LargeObject　open(int　oid,
　　　　　　　　　　　　　　　　　　　　　　　　　int　mode)　throws　SQLException
　　　　　　　　　　
　　　　　　　　　　這個方法打開一個現有的大對象,　以其　OID　為基礎.
　　
　　　　　　　　參數:
　　　　　　　　　　　　　　　　oid　-　大對象標識　(oid)
　　　　　　　　　　　　　　　　mode　-　打開模式

　　　　　　　　返回:
　　　　　　　　　　　　　　　　提供訪問大對象的方法的　LargeObject　實例

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時

　public　int　create()　throws　SQLException

　　　　　　　　　　這個方法創建一個大對象,　返回它的　OID.

　　　　　　　　　　它把新創建的大對象模式設為缺省的　READWRITE　.

　　　　　　　　返回:
　　　　　　　　　　　　　　　　新對象的　oid　(對象標識)

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時

　public　int　create(int　mode)　throws　SQLException

　　　　　　　　　　這個方法創建一個大對象,　返回它的　OID.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　mode　-　一個描述新對象不同屬性的位掩碼

　　　　　　　　返回:
　　　　　　　　　　　　　　　　新對象的　oid　(對象標識)

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時

　public　void　delete(int　oid)　throws　SQLException
　　　　　　　　　　
　　　　　　　　　　這個方法刪除一個大對象.
　　　　　　　　　　
　　　　　　　　參數:
　　　　　　　　　　　　　　　　oid　-　描述要刪除的對象

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時

　public　void　unlink(int　oid)　throws　SQLException

　　　　　　　　　　這個方法刪除一個大對象.

　　　　　　　　　　這個方法等同于　delete　方法,　并且作為類似使用　unlink　的
C　API　出現.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　oid　-　描述要刪除的對象

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時

對象的串行化　(Object　Serialisation)PostgreSQL　不是通常的　SQL　數據庫.　它比其他數據庫有更強的可擴展性,
并且支持面向對象的特性,　這一點另　postgresql　非常獨特.

這些特性的一個結果就是你可以擁有一個引用其他表的行的表,　例如:

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　接口,　你就可以把一個對象存儲成一個
　Stream　(流).　這個過程稱為對象串行化　(Object　Serialization),　可以用于將復雜的對象存入數據庫.

現在,　在　JDBC　里,　你將不得不使用一個　LargeObject　來存儲它們.不過,　你不能在這些對象上執行查詢.

postgresql.util.Serialize　類做的工作就是提供一個把一個對象存儲為表的方法,
并且從一個表中檢索出該對象.　大多數情況下,　你將不需要直接訪問這個類,
但是你要用到　PreparedStatement.setObject()　和　
ResultSet.getObject()　方法.　這些方法將對照數據庫里的表檢查對象類的名稱,
如果找到一個匹配的,　它就假設該對象是一個串行化了的對象
然后從該表中檢索出對象來.　在這么做的同時,　如果該對象包含其他串行化對象
那么它遞歸地檢索這個嵌套樹.

聽起來很復雜?　實際上,　它比我寫的要簡單　-　只是解釋起來困難些.

你可能訪問這個類的唯一機會是使用　create()　方法.　這些不會被驅動使用,　只是對數據庫執行一條或更多條
"create　table"　語句　-　以你想要串行化的表或　Java　對象為基礎.

哦,　最后一件事情.　如果你的對象包含象這樣的一行:

　　　　　public　int　oid;

那么,　當對象從表里檢索出來時,　它被設置為表里的　oid.　
那么,　如果該對象被修改,　然后重新串行化,　那么現有的記錄將被更新.

如果不存在　oid　變量,　那么當對象串行化時,　它總是被插入表中,　而任何現存的記錄將保留.

在串行化之前把　oid　設為　0　將同樣導致對象被插入.這樣就使在表中復制對象成為可能.

Class　postgresql.util.Serialize

java.lang.Object
　　　|
　　　+----postgresql.util.Serialize

　　　公共類　Serialize　擴展　Object

　　　這個類使用　PostgreSQL　的面向對象的特性存儲　Java　對象.　
它通過把　Java　Class　的名稱映射到一個數據庫里的表實現這一點.
這樣,　這個新表里的每條記錄都代表一個這個類的串行化了的實例.
因為每條記錄都有一個　OID　(Object　IDentifier　對象標識),　
這個　OID　可以被包含在其他表里.　在這里演示實在是太復雜了,　將在主文檔里記錄更多的細節.

構造(方法)

　public　Serialize(Connection　c,
　　　　　　　　　　　　　　　　　　String　type)　throws　SQLException

　　　　　　　　　　這個方法創建一個可以用于從一個　PostgreSQL　表里串行化一個　Java　對象的實例.

方法

　public　Object　fetch(int　oid)　throws　SQLException

　　　　　　　　　　這個方法通過給出的　OID　從一個表里抓取一個對象.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　oid　-　對象的　oid　(對象標識)

　　　　　　　　返回:
　　　　　　　　　　　　　　　　與　oid　相關的　Object　(對象)

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時

　public　int　store(Object　o)　throws　SQLException

　　　　　　　　　　這個方法把一個對象存入一個表中,　返回它的　OID.

　　　　　　　　　　如果對象有一個　int　(整數)叫　OID,　并且　>　0,　那么那個值
用于　OID,　并且表將被更新.　如果　OID　的值是　0,　那么將創建一個新行,　而且
OID　的值將被設置在對象里(對象必須實現串行化).　這樣就使一個對象在數據庫里的值被更新成為可能.
如果對象沒有名為　OID　的　int　(整數),　那么對象被存儲.　不過,　如果對象隨后被檢索,　改動并且重新
存儲,　那么它的新狀態將被附加到表上,　并且將不覆蓋原來的記錄.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　o　-　待存儲的　Object　對象　(必須實現串行化)

　　　　　　　　返回:
　　　　　　　　　　　　　　　　存儲了的對象的　oid　

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時
　
　public　static　void　create(Connection　con,
　　　　　　　　　　　　　　　　　　　　　　　　　　　Object　o)　throws　SQLException

　　　　　　　　　　這個方法不被驅動使用,　但是它創建一個表,　給出一個可串行化的　Java　對象.　
應該在串行化任何對象之前使用它.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　c　-　與數據庫的　Connection　(聯接)
　　　　　　　　　　　　　　　　o　-　表所依賴的　Object　(對象)

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時

　　　　　　　　返回:
　　　　　　　　　　　　　　　　與　Object　(對象)相關的　oid

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時

　public　int　store(Object　o)　throws　SQLException

　　　　　　　　　　這個方法存儲一個對象到表里面,　返回對象的　OID.

　　　　　　　　　　如果對象有一個　int　(整數)叫　OID,　并且　>　0,　那么那個值
用于　OID,　并且表將被更新.　如果　OID　的值是　0,　那么將創建一個新行,　而且
OID　的值將被設置在對象里.　這樣就使一個對象在數據庫里的值被更新成為可能.
如果對象沒有名為　OID　的　int　(整數),　那么對象被存儲.　不過,　如果對象隨后被檢索,　改動并且重新
存儲,　那么它的新狀態將被附加到表上,　并且將不覆蓋原來的記錄.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　o　-　要存儲的　Object　(對象)　(必須實現串行化)

　　　　　　　　返回:
　　　　　　　　　　　　　　　　存儲了的對象的　oid　

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時
　
　public　static　void　create(Connection　con,
　　　　　　　　　　　　　　　　　　　　　　　　　　　Object　o)　throws　SQLException

　　　　　　　　　　這個方法不被驅動使用,　但是它創建一個表,　給出一個可串行化的　Java　對象.　
應該在串行化任何對象之前使用它.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　c　-　與數據庫的　Connection　(聯接)
　　　　　　　　　　　　　　　　o　-　表所依賴的　Object　(對象)

　　　　　　　　拋出:　SQLException
　　　　　　　　　　　　　　　　出錯時
　　　　　　　　　　　　　　　　
　public　static　void　create(Connection　con,
　　　　　　　　　　　　　　　　　　　　　　　　　　　Class　c)　throws　SQLException

　　　　　　　　　　這個方法不被驅動使用,　但是它創建一個表,　給出一個可串行化的　Java　對象.　
應該在串行化任何對象之前使用它.

　　　　　　　　參數:
　　　　　　　　　　　　　　　　c　-　與數據庫的　Connection　(聯接)
　　　　　　　　　　　　　　　　o　-　表所依賴的　Object　(對象)

　　　　　　　　拋出:　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
　　　　　　　　　　　　　　　　出錯時

工具類

postgresql.util　包包含被主驅動內部使用的類以及其他擴展.

Class　postgresql.util.PGmoney
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
java.lang.Object
　　　|
　　　+----postgresql.util.PGobject
　　　　　　　　　　　|
　　　　　　　　　　　+----postgresql.util.PGmoney

　　　公共類　PGmoney　擴展　PGobject　實現　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

　　　　　　　　參數:
　　　　　　　　　　　　　　　　obj　-　要比較的對象
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　返回:
　　　　　　　　　　　　　　　　如果兩個對象相同返回真　(true)

　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　equals

　public　boolean　equals(Object　obj)

　　　　　　　　參數:
　　　　　　　　　　　　　　　　obj　-　要比較的對象
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　返回:
　　　　　　　　　　　　　　　　如果兩個對象相同返回真　(true)

　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　equals

　public　Object　clone()
　　　　　　　　　　　　　　　　
　　　　　　　　　　必須重載這個方法以便允許這個對象被克隆

　　　　　　　　重載:
　　　　　　　　　　　　　　　　類　PGobject　里的　clone
　public　String　getValue()

　　　　　　　　返回:
　　　　　　　　　　　　　　　　postgresql　希望的貨幣?

上一篇：PostgreSQL7.0手冊-接口-59. Lisp 編程接口

下一篇：PostgreSQL7.0手冊-接口-57. ODBC 接口