83、Jython数据库编程全解析

Jython数据库编程全解析

在编程领域，数据库操作是至关重要的一部分。Jython作为一种结合了Python和Java特性的语言，为数据库编程提供了丰富的功能和灵活的选择。本文将详细介绍Jython在数据库编程方面的应用，包括DBM文件、对象序列化、数据库管理系统（如MySQL和PostgreSQL）、JDBC以及zxJDBC等内容。

DBM文件

DBM文件是一种哈希数据库文件，其行为类似于字典对象。不过，这种相似性存在一定限制，因为当前的实现并未使用所有字典方法，并且所有DBM的键和值都必须是字符串。在Jython中，有多种DBM工具可供使用，但目前只有dumbdbm与Jython捆绑在一起。尽管dumbdbm的名字不太吸引人，实现也较为简单且速度较慢，但它是一个相对有效的DBM克隆。未来，可能会有更多的DBM模块可供Jython使用。

以下是一个使用dumbdbm模块的简单交互式示例：

>>> import dumbdbm 
>>> dbm = dumbdbm.open("dbmtest") 
>>> dbm['Value 1'] = 'A' 
>>> dbm['Value 2'] = 'B' 
>>> dbm['Value 3'] = 'B' 
>>> for key in dbm.keys(): 
...     print key, ":", dbm[key] 
... 
Value 3 : B 
Value 2 : B 
Value 1 : A 
>>> 
>>> dir(dbm.__class__) 
['__delitem__', '__doc__', '__getitem__', '__init__', '__len__', 
'__module__', '__setitem__', '_addkey', '_addval', '_commit', '_setval', 
'_update', 'close', 'has_key', 'keys'] 
>>> 
>>> dbm.close() 

通过 dir(dbm.__class__) 方法可以看出，dbm对象与字典有所不同。在字典方法中，只有 keys 和 has_key 被实现。不过，DBM对象具有一个显著的优势，即它是持久的。重新打开 dbmtest 目录可以看到之前输入的值：

>>> import dumbdbm 
>>> dbm = dumbdbm.open("dbmtest") 
>>> for key in dbm.keys(): 
...     print key, ":", dbm[key] 
... 
Value 3 : B 
Value 2 : B 
Value 1 : A 
>>> dbm.close() 

打开一个新的dumbdbm目录实际上会创建两个文件：一个扩展名为 .dir ，另一个扩展名为 .dat 。在 open 函数中，只需要指定目录名称，不需要扩展名。其他DBM实现允许在 open 函数中使用标志和模式参数，但dumbdbm会忽略这些参数。

序列化

序列化是将对象转换为适合传输或存储的流的过程。存储部分是将此主题与数据库相关联的原因，因为序列化对象通常存储在数据库中。要序列化Jython对象，可以使用 marshal 、 pickle 或 cPickle 模块。 marshal 模块仅适用于内置类型，而 pickle 模块适用于内置对象、模块全局类和函数以及大多数实例对象。 cPickle 模块是 pickle 模块的高性能Java版本，其名称借鉴自CPython的 cPickle 模块，但并不意味着它是用C编写的。 shelve 模块将数据库与 pickle 结合起来，创建持久的对象存储。Jython的 PythonObjectInputStream 是一个 ObjectInputStream ，在反序列化继承自Java类的Jython对象时，它有助于解析类。

marshal模块

marshal 模块用于序列化代码对象和内置数据对象。尽管它在某些项目中仍会出现，但通常会被下面介绍的 cPickle 模块所取代。需要注意的是， marshal 模块对CPython的一个吸引力在于它能够编译代码对象，但对于Jython对象目前并非如此，因此 marshal 模块的使用相对较少。

marshal 模块有四个方法： dump 、 dumps 、 load 和 loads 。 dump 和 load 方法用于将对象序列化到文件和从文件中恢复对象，因此 dump 的参数是要序列化的对象和文件对象，而 load 的参数只是文件对象。传递给 dump 和 load 函数的文件对象必须以二进制模式打开。 dumps 和 loads 方法用于将对象序列化到字符串和从字符串中恢复对象。

以下是一个使用 marshal 模块处理列表对象的交互式示例：

>>> import marshal 
>>> file = open("myMarshalledData.dat", "w+b") # Must be Binary mode 
>>> L = range(30, 50, 7) 
>>> marshal.dump(L, file)  # serialize object L to 'file' 
>>> 
>>> file.flush()  # flush or close after the dump to ensure integrity 
>>> file.seek(0)  # put file back at beginning for load() 
>>> 
>>> restoredL = marshal.load(file) 
>>> print L 
[30, 37, 44] 
>>> print restoredL 
[30, 37, 44] 

pickle和cPickle模块

pickle 和 cPickle 模块是序列化Jython对象的首选方法。它们之间的区别仅在于实现和性能，使用方法相同。除了Java对象、代码对象以及具有复杂 __getattr__ 和 __setattr__ 方法的Jython对象外，大多数对象都可以使用 pickle 或 cPickle 进行序列化。以下是 pickle 模块的四个主要函数：
| 方法 | 描述 |
| — | — |
| Dump(object, file[, bin]) | 将内置数据对象序列化到先前打开的文件对象。如果对象无法序列化，将引发 PicklingError 异常。 pickle 可以使用文本或二进制格式。第三个参数为零或缺失表示文本格式，非零表示二进制格式。 |
| Load(file) | 从先前打开的文件对象中读取并反序列化数据。如果腌制的数据是以二进制模式写入文件的，则提供给 load 的文件对象也必须以二进制模式打开。 |
| dumps(object[, bin]) | 将对象序列化为字符串对象，而不是文件。如果对象无法序列化，将引发 PicklingError 异常。第二个参数为零或缺失表示文本格式，非零表示二进制格式。 |
| loads(string) | 将字符串反序列化为数据对象。 |

以下是一个使用 cPickle 模块存储 product 类实例的简单交互式示例：

>>> import cPickle 
>>> class product: 
...     def __init__(self, productCode, data): 
...         self.__dict__.update(data) 
...         self.productCode = productCode 
... 
>>> data = {'name':'widget', 'price':'112.95', 'inventory':1000} 
>>> widget = product('1123', data) 
>>> f = open(widget.productCode, 'wb') 
>>> cPickle.dump(widget, f, 1) 
>>> f.close() 

现在， widget 产品存储在名为 1123 的文件中。恢复这个实例需要使用 cPickle.load 函数，但为了正确重建实例，其类必须存在于反序列化的命名空间中。

>>> import cPickle 
>>> class product: 
...     def __init__(self, productCode, data): 
...         self.__dict__.update(data) 
...         self.productCode = productCode 
... 
>>> f = open("1123", "rb") 
>>> widget = cPickle.load(f) 
>>> f.close() 
>>> vars(widget) 
{'name': 'widget', 'productCode': '1123', 'price': '112.95', 'inventory': 1000} 

对象可以通过定义特殊方法 __getstate__ 和 __setstate__ 来控制其序列化和反序列化过程。如果定义了 __getstate__ ，则在对象被腌制时，其返回值将被序列化。如果定义了 __setstate__ ，则在重建对象时，将使用反序列化的数据（即 __getstate__ 返回的值）调用该方法。

你也可以使用 pickler 和 unpickler 对象。要创建这些对象，需要将适当的文件对象提供给 pickle.Pickler 或 pickle.Unpickler 类。

>>> import cPickle 
>>> f = open("picklertest", "w+b") 
>>> p = cPickle.Pickler(f) 
>>> u = cPickle.Unpickler(f) 
>>> 
>>> L = range(10) 
>>> p.dump(L)  # use pickler object to serialize 
>>> f.seek(0) 
>>> print u.load() 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

pickle 可以处理递归数据结构、包含自身引用的对象以及嵌套数据结构。 Pickler 对象会存储所有先前腌制对象的引用，确保对同一对象的后续引用不会再次进行序列化。

Shelves

Jython的 shelve 模块将DBM目录的便利性与 pickle 的序列化功能相结合，创建持久的对象存储。 shelve 的行为类似于字典，与 dumbdbm 模块类似，但不同之处在于 shelve 允许任何可腌制的对象作为值，尽管键仍然必须是字符串。以下是一个使用 shelve 模块的交互式示例：

>>> import shelve, dumbdbm 
>>> dbm = dumbdbm.open("dbmdata") 
>>> shelf = shelve.Shelf(dbm) 
>>> shelf['a list'] = range(10) 
>>> shelf['a dictionary'] = {1:1, 2:2, 3:3} 
>>> print shelf.keys() 
['a list', 'a dictionary'] 
>>> shelf.close() 

你也可以直接使用 shelve 的 open 方法：

>>> import shelve 
>>> shelf = shelve.open("dbmdata") 

PythonObjectInputStream

在Java中序列化Jython对象的过程与序列化Java对象基本相同，唯一的区别是 org.python.util.PythonObjectInputStream 。通常，Jython对象可以像预期的那样从Java进行序列化和反序列化，但 PythonObjectInputStream 在反序列化继承自Java类的Jython对象时，有助于解析类。

以下是在Java中序列化Jython对象的伪代码示例：

// Import required classes 
import java.io.*; 
import org.python.core.*; 
// Identify the resource 
String file = "someFileName"; 
// To serialize, make an OutputStream (FileOutputStream in this case) 
// and then an ObjectOutputStream. 
FileOutputStream oStream = new FileOutputStream(file); 
ObjectOutputStream objWriter = new ObjectOutputStream(oStream); 
// Write a simple Jython object 
objWriter.writeObject(new PyString("some string")); 
// clean up 
objWriter.flush(); 
oStream.close(); 

反序列化对象可以使用 ObjectInputStream 或 PythonObjectInputStream ：

// Import required classes 
import java.io.*; 
import org.python.core.*; 
import org.python.util.PythonObjectInputStream; 
// Identify the resource 
String file = "someFileName"; 
// Open an InputStrea (FileInputStream in this case) 
FileInputStream iStream = new FileInputStream(file); 
// Use the input stream to open an ObjectInputStream or a 
// PythonObjectInputStream. 
PythonObjectInputStream objReader = 
    new PythonObjectInputStream(iStream); 
// It could be this for objects without java superclasses 
// ObjectInputStream objReader = new ObjectInputStream(iStream); 
// Read the object 
PyObject po = (PyObject)objReader.readObject(); 
// clean up 
iStream.close(); 

数据库管理系统

Jython可以与任何具有Java驱动程序的数据库一起使用，但本文主要介绍MySQL和PostgreSQL数据库管理系统（DBMS）。这两个数据库非常流行、免费、稳定，并且有大量的文档。

MySQL

MySQL是一个SQL数据库服务器，可在大多数类UNIX平台和Windows上运行。要运行与MySQL相关的示例，需要下载并安装MySQL及其相关的JDBC驱动程序。MySQL可以从 http://www.mysql.com/ 的“downloads”部分下载，MySQL JDBC驱动程序也可以在同一网站的下载部分找到，最新的驱动程序和发布信息可在 http://mmmysql.sourceforge.net/ 获取。本文使用的JDBC驱动程序版本是 mm.mysql-2.0.4-bin.jar 。

安装MySQL后，需要添加用户和数据库。以下是一些基本的设置步骤：
1. 启动服务器 ：
- 在类UNIX系统上： /pathToMysql/bin/safe_mysqld &
- 在Windows上： \pathToMysql\bin\winmysqladmin.exe
2. 创建数据库 ：

C:\mysql\bin>mysql 
Welcome to the MySQL monitor. Commands end with ; or \g. 
Your MySQL connection id is 3 to server version: 3.23.39 
Type 'help;' or '\h' for help. Type '\c' to clear the buffer. 
mysql> CREATE DATABASE test; 
Query OK, 1 row affected (0.33 sec) 

3. 确认数据库存在 ：

mysql> SHOW DATABASES\g 
+----------+ 
| Database | 
+----------+ 
| mysql    | 
| test     | 
+----------+ 
2 rows in set (0.00 sec) 

4. 添加用户 ：

mysql> USE test; 
mysql> GRANT ALL ON test TO jyuser@localhost IDENTIFIED BY "beans"; 
Query OK, 0 rows affected (0.05 sec) 

PostgreSQL

PostgreSQL是一个功能强大的对象关系数据库管理系统（ORDBMS），可在大多数类UNIX平台和Windows 2000/NT上运行。要运行与PostgreSQL相关的示例，需要下载并安装PostgreSQL服务器和PostgreSQL JDBC驱动程序，可从 http://www.postgresql.org/ 获取。

以下是安装和设置PostgreSQL的步骤：
1. 安装 ：
- 在类UNIX系统上，下载适合系统的包格式并运行包管理器。
- 在Windows 2000/NT系统上，需要先下载Cygwin和cygipc包，以模拟UNIX环境。
2. 初始化数据库集群 ：

initdb -D /usr/local/pgsql/data 

3. 配置 pg_hba.conf 文件 ：该文件控制哪些主机可以连接到数据库。例如，允许本地机器连接到 test 数据库的配置如下：

host test 127.0.0.1 255.255.255.255 crypt 

4. 创建用户 ：

[shell prompt]$ createuser -U postgres -d -P jyuser 
Enter password for user "jyuser": 
Enter it again: 
Shall the new user be allowed to create more new users? (y/n) n 
CREATE USER 

5. 创建测试数据库 ：

[shell prompt]$ createdb -U jyuser test 
CREATE DATABASE 

6. 启动服务器 ：

postmaster -i -D /usr/local/pgsql/data & 

JDBC

Java使用JDBC和 java.sql 包与SQL数据库进行交互，这意味着Jython也可以使用这些工具。使用JDBC API和 java.sql 包与SQL数据库交互只需要相应的JDBC驱动程序和数据库。

连接数据库

数据库连接需要JDBC URL、用户名和密码。在进行连接之前，需要了解JDBC URL的格式。

JDBC URL

JDBC URL是一个字符串，用于唯一标识数据库连接。其语法如下：

jdbc:<subprotocol>:<subname> 

以下是MySQL和PostgreSQL的JDBC URL语法：
- MySQL： jdbc:mysql://[hostname][:port]/databaseName[parameter=value]
- PostgreSQL： jdbc:postgresql://[hostname][:port]/databaseName[parameter=value]

例如，连接本地 test 数据库的URL可以简化为：
- MySQL： jdbc:mysql:///test
- PostgreSQL： jdbc:postgresql:///test

以下是一些其他数据库驱动程序的JDBC URL示例：
| 驱动程序 | URL |
| — | — |
| COM.ibm.db2.jdbc.net.DB2Driver | jdbc:db2//localhost/test |
| oracle.jdbc.driver.OracleDriver | jdbc:oracle:thin:@localhost:ORCL |
| sun.jdbc.odbc.JdbcOdbcDriver | JDBC:ODBC:test |
| informix.api.jdbc.JDBCDriver | jdbc:informix-sqli://localhost/test |

在JDBC URL的末尾，可以指定连接参数。以下是一些常见的参数：
| 参数 | 含义 | 默认值 | 适用数据库 |
| — | — | — | — |
| User | 数据库用户名 | 无 | 两者 |
| password | 密码 | 无 | 两者 |
| autoReconnect | 连接断开时是否尝试重新连接（ true 或 false ） | false | MySQL |
| maxReconnects | 驱动程序尝试重新连接的次数（假设 autoReconnect 为 true ） | 3 | MySQL |
| initialTimeout | 重新连接前等待的秒数（假设 autoReconnect 为 true ） | 2 | MySQL |
| maxRows | 返回的最大行数（0表示所有行） | 0 | MySQL |
| useUnicode | 是否使用Unicode（ true 或 false ） | false | MySQL |
| characterEncoding | 使用的Unicode字符编码（如果 useUnicode 为 true ） | 无 | MySQL |

JDBC连接

使用Java的数据库连接性建立数据库连接的步骤如下：
1. 将适当的驱动程序包含在类路径中。
2. 向JDBC DriverManager注册驱动程序。
3. 向 java.sql.DriverManager.getConnection 方法提供JDBC URL、用户名和密码。

以下是添加MySQL和PostgreSQL JDBC驱动程序到类路径的示例：

# For MySQL 
set CLASSPATH=\path\to\mm_mysql-2_0_4-bin.jar;%CLASSPATH% 
# For PostgreSQL 
set CLASSPATH=\path\to\jdbc7.1-1.2.jar;%CLASSPATH% 

注册驱动程序有两种基本方法：
- 使用 -D 开关在命令行上设置 jdbc.drivers 属性。
- 使用 java.lang.Class.forName(classname) 方法。

以下是使用 Class.forName 加载MySQL和PostgreSQL驱动程序的示例：

import java 
try: 
    java.lang.Class.forName("org.gjt.mm.mysql.Driver") 
    java.lang.Class.forName("org.postgresql.Driver") 
except java.lang.ClassNotFoundException: 
    print "No appropriate database driver found" 
    raise SystemExit 

连接数据库的示例如下：

from java.sql import DriverManager 
from java.util import Properties 
# Using the getConnection(URL) method 
mysqlConn = DriverManager.getConnection(
    "jdbc:mysql://localhost/test?user=jyuser&password=beans") 
postgresqlConn = java.sql.DriverManager.getConnection(
    "jdbc:postgresql://localhost/test?user=jyuser&password=beans") 
# Using the getConnection(URL, Properties) method 
params = Properties() 
params.setProperty("user", "jyuser") 
params.setProperty("password", "beans") 
mysqlConn = DriverManager.getConnection("jdbc:mysql://localhost/test", 
                                        params) 
postgresqlConn = 
    DriverManager.getConnection("jdbc:postgresql://localhost/test", 
                                params) 
# Using the getConnection(URL, String, String) method 
mysqlConn = 
    DriverManager.getConnection("jdbc:mysql://localhost/test", 
                                "jyuser", "beans") 
postgresqlConn = 
    DriverManager.getConnection("jdbc:postgresql://localhost/test", 
                                "jyuser", "beans") 

连接脚本

Jython的交互式解释器是一个理想的数据库客户端工具。可以通过编写连接脚本来简化数据库连接过程。以下是一个数据库客户端启动脚本的示例：

# File: mystart.py 
from java.lang import Class 
from java.sql import DriverManager 
from org.python.util import InteractiveConsole 
import sys 
url = "jdbc:mysql://localhost/%s" 
user, password = "jyuser", "beans" 
# Register driver 
Class.forName("org.gjt.mm.mysql.Driver") 
# Allow database to be optionally set as a command-line parameter 
if len(sys.argv) == 2: 
    url = url % sys.argv[1] 
else: 
    url = url % "test" 
# Get connection 
dbconn = DriverManager.getConnection(url, user, password) 
# Create statement 
try: 
    stmt = dbconn.createStatement() 
except: 
    dbconn.close() 
    raise SystemExit 
# Create inner console 
interp = InteractiveConsole({"dbconn":dbconn, "stmt":stmt}, "DB Shell") 
try: 
    interp.interact("Jython DB client") 
finally: 
    # Close resources 
    stmt.close() 
    dbconn.close() 
    print 

要连接到 test 数据库，只需确保适当的驱动程序在类路径中，然后运行 jython mystart.py 。

连接对话框

另一种常见的连接任务是使用对话框获取连接信息。以下是一个数据库连接对话框的示例代码：

# File: DBLoginDialog.py 
import sys 
import java 
from java import awt 
from java import sql 
import pawt 
class DBLoginDialog(awt.Dialog): 
    '''DBLoginDialog prompts a user of database information and 
    establishes a database login. A connection receiver is registered 
    as client- for example: 
       def connectionClient(dbconnection): 
           # do something with database connection 
       dbl = DBLoginDialog(parentframe, message) 
       dbl.client = connectionClient''' 
    def __init__(self, parentFrame, message): 
        awt.Dialog.__init__(self, parentFrame) 
        self.client = None 
        self.background = pawt.colors.lightgrey 
        bag = pawt.GridBag(self, anchor='WEST', fill='NONE') 
        # Make required components 
        self.Hostname = HighlightTextField("localhost", 24) 
        self.DBMS = awt.Choice(itemStateChanged=self.updatePort) 
        self.Port = HighlightTextField("3306", 5) 
        self.Database = HighlightTextField("test",12) 
        self.User = HighlightTextField("jyuser", 10) 
        self.Password = HighlightTextField("", 10, echoChar='*') 
        # Fill the choice component with opions 
        self.DBMS.add("MySQL") 
        self.DBMS.add("PostgreSQL") 
        # add message 
        bag.addRow(awt.Label(message), anchor='CENTER') 
        # Put components in the bag 
        for x in ["Hostname", "DBMS", "Port", "Database", 
                  "User", "Password"]: 
            bag.add(awt.Label(x + ":")) 
            bag.addRow(self.__dict__[x]) 
        # Add action buttons 
        bag.add(awt.Button("Login", actionPerformed=self.login), 
                fill='HORIZONTAL') 
        bag.addRow(awt.Button("Cancel", actionPerformed= self.close), 
                   anchor='CENTER') 
        self.pack() 
        bounds = parentFrame.bounds 
        self.bounds = (bounds.x + bounds.width/2 - self.width/2, 
                       bounds.y + bounds.height/2 - self.height/2, 
                       self.width, self.height) 
    def login(self, e): 
        db = self.DBMS.selectedItem 
        if db == "MySQL": 
            driver = "org.gjt.mm.mysql.Driver" 
        else: 
            driver = "org.postgresql.Driver" 
        try: 
            java.lang.Class.forName(driver) 
        except java.lang.ClassNotFoundException: 
            self.showError("Unable to load driver %s" % driver) 
            return 
        url = "jdbc:%s://%s:%s/%s" % (db.lower(), self.Hostname.text, 
                                       self.Port.text, 
                                       self.Database.text) 
        try: 
            dbcon = sql.DriverManager.getConnection(url, 
                                                    self.User.text, 
                                                    self.Password.text) 
            self.dispose() 
            self.client(dbcon) 
        except sql.SQLException: 
            self.showError("Unable to connect to database") 
    def updatePort(self, e): 
        if self.DBMS.selectedItem == 'MySQL': 
            port = '3306' 
        elif self.DBMS.selectedItem == 'PostgreSQL': 
            port = '5432' 
        self.Port.text = port 
    def setClient(self, client): 
        self.client = client 
    def showError(self, message): 
        d = awt.Dialog(self.parent, "Error") 
        panel = awt.Panel() 
        panel.add(awt.Label(message)) 
        button = awt.Button("OK") 
        panel.add(button) 
        d.add(panel) 
        d.pack() 
        bounds = self.parent.bounds 
        d.bounds = (bounds.x + bounds.width/2 - d.width/2, 
                    bounds.y + bounds.height/2 - d.height/2, 
                    d.width, d.height) 
        d.windowClosing = lambda e, d=d: d.dispose() 
        button.actionPerformed = d.windowClosing 
        d.visible = 1 
    def close(self, e): 
        self.dispose() 
class HighlightTextField(awt.TextField, awt.event.FocusListener): 
    def __init__(self, text, chars, **kw): 
        awt.TextField.__init__(self, text, chars) 
        self.addFocusListener(self) 
        for k in kw.keys(): 
            exec("self." + k + "=kw[k]") 
    def focusGained(self, e): 
        e.source.selectAll() 
    def focusLost(self, e): 
        e.source.select(0, 0) 
def dummyClient(connection): 
    if connection != None: 
        print "\nDatabase connection successfully received by client." 
        print "Connection=", connection 
        connection.close() 
        print "Database connection properly closed by client." 
if __name__ == '__main__': 
    # make a dummy frame to parent the dialog window 
    f = awt.Frame("DB Login", windowClosing=lambda e: sys.exit()) 
    screensize = f.toolkit.screenSize 
    f.bounds = (screensize.width/2 - f.width/2, 
                screensize.height/2 - f.height/2, 
                f.width, f.height) 
    # create and show the dialog window 
    dbi = DBLoginDialog(f, "Connection Information") 
    dbi.client = dummyClient 
    dbi.windowClosing = dbi.windowClosed = lambda e: sys.exit() 
    dbi.visible = 1 

要执行 DBLoginDialog ，需要确保适当的数据库驱动程序在类路径中，然后执行 jython DBLoginDialog.py 。

数据库元数据

连接到数据库后，可以探索数据库和连接的元数据。Java连接对象（ java.sql.Connection ）有一个 getMetaData 方法，返回一个 java.sql.DatabaseMetaData 对象，该对象提供有关数据库连接的详细信息。

以下是一个交互式示例，用于发现MySQL的系统函数、数值函数和对事务的支持：

>>> import java 
>>> from java.sql import DriverManager 
>>> 
>>> # Register driver 
>>> java.lang.Class.forName("org.gjt.mm.mysql.Driver") 
<jclass org.gjt.mm.mysql.Driver at 650329> 
>>> 
>>> # Get Connection 
>>> url, user, password = "jdbc:mysql:///test", "jyuser", "beans" 
>>> dbconn = DriverManager.getConnection(url, user, password) 
>>> 
>>> # Get the DatabaseMetaData object 
>>> md = dbconn.getMetaData() 
>>> 
>>> # Use the metadata object to find info about MySQL 
>>> print md.systemFunctions 
DATABASE,USER,SYSTEM_USER,SESSION_USER,PASSWORD,ENCRYPT,LAST_INSERT_ID, 
VERSION 
>>> md.numericFunctions 
'ABS,ACOS,ASIN,ATAN,ATAN2,BIT_COUNT,CEILING,COS,COT,DEGREES,EXP,FLOOR,LOG, 
LOG10,MAX,MIN,MOD,PI,POW,POWER,RADIANS,RAND,ROUND,SIN,SQRT,TAN,TRUNCATE' 
>>> md.supportsTransactions() 
0 
>>> 
>>> # Don't forget to close connections 
>>> dbconn.close() 

语句

与MySQL和PostgreSQL交互的主要方式是执行SQL语句。要创建语句对象，可以使用连接对象的 createStatement() 方法。

以下是一个创建语句对象并执行SQL语句的示例：

>>> import java 
>>> java.lang.Class.forName("org.gjt.mm.mysql.Driver") 
<jclass org.gjt.mm.mysql.Driver at 1876475> 
>>> db, user, password = "test", "jyuser", "beans" 
>>> url = "jdbc:mysql://localhost/%s" % db 
>>> dbconn = java.sql.DriverManager.getConnection(url, user, password) 
>>> stmt = dbconn.createStatement() 

可以设置语句对象的类型和并发参数，以创建可更新的结果集：

>>> import java 
>>> from java import sql 
>>> java.lang.Class.forName("org.gjt.mm.mysql.Driver") 
<jclass org.gjt.mm.mysql.Driver at 1876475> 
>>> db, user, password = "test", "jyuser", "beans" 
>>> url = "jdbc:mysql://localhost/%s" % db 
>>> dbconn = sql.DriverManager.getConnection(url, user, password) 
>>> 
>>> type = sql.ResultSet.TYPE_SCROLL_SENSITIVE 
>>> concurrency = sql.ResultSet.CONCUR_UPDATABLE 
>>> stmt = dbconn.createStatement(type, concurrency) 

语句对象有三个主要方法用于执行SQL语句：
- execute() ：返回0或1，表示是否有ResultSet。
- executeQuery() ：始终返回ResultSet。
- executeUpdate() ：返回受影响的行数。

以下是一些示例：

>>> query = "CREATE TABLE random ( number tinyint, letter char(1) )" 
>>> stmt.execute(query) 
0 
>>> print stmt.resultSet 
None 
>>> import string, random 
>>> for i in range(20): 
... number = random.randint(0, 51) 
... query = "INSERT INTO random (number, letter) VALUES (%i, '%s')" 
... query = query % (number, string.letters[number - 1]) 
... stmt.executeUpdate(query) 
1 
... 

结果集

使用 executeQuery 方法返回的对象是ResultSet。 java.sql.ResultSet 对象包含许多方法，用于导航结果和将结果作为Java原生类型检索。

以下是一个遍历ResultSet的示例：

>>> import java 
>>> java.lang.Class.forName("org.gjt.mm.mysql.Driver") 
<jclass org.gjt.mm.mysql.Driver at 1876475> 
>>> db, user, password = "test", "jyuser", "beans" 
>>> url = "jdbc:mysql://localhost/%s" % db 
>>> dbconn = java.sql.DriverManager.getConnection(url, user, password) 
>>> stmt = dbconn.createStatement() 
>>> 
>>> rs = stmt.executeQuery("SELECT * FROM random") 
>>> while rs.next(): 
... print rs.getString('letter'), ": ", rs.getInt('number') 
... 
... 
U : 46 
K : 36 
h : 7 
Q : 42 
l : 11 
u : 20 
n : 13 
z : 25 
U : 46 
Y : 50 
j : 9 
o : 14 
i : 8 
s : 18 
d : 3 
A : 26 
K : 36 
j : 9 
n : 13 
g : 6 
>>> stmt.close() 
>>> dbconn.close() 

ResultSet的导航方法根据JDBC版本和语句类型而有所不同。在JDBC 2.0之前，导航仅限于 next() 方法，当前版本支持更多方法，如 first() 、 last() 、 previous() 等。

预编译语句

预编译频繁使用的SQL语句通常可以提高效率。可以使用连接对象的 prepareStatement 方法创建预编译语句。

以下是一个示例：

>>> import java 
>>> from java import sql 
>>> java.lang.Class.forName("org.postgresql.Driver") 
<jclass org.gjt.mm.mysql.Driver at 1876475> 
>>> dbconn = sql.DriverManager.getConnection(url, user, password) 
>>> query = "INSERT INTO random (letter, number) VALUES (?, ?)" 
>>> preppedStmt = dbconn.prepareStatement(query) 
>>> preppedStmt.clearParameters() 
>>> preppedStmt.setString(1, "f") 
>>> preppedStmt.setInt(2, 6) 
>>> preppedStmt.executeUpdate() 
1 
>>> preppedStmt.close() 
>>> dbconn.close() 

事务

事务是一组数据库操作，必须全部成功完成，否则整个操作将被撤销（回滚）。以下是一个使用PostgreSQL和 random 表的事务示例：

>>> import java 
>>> from java import sql 
>>> java.lang.Class.forName("org.postgresql.Driver") 
<jclass org.postgresql.Driver at 5711596> 
>>> url = "jdbc:postgresql://localhost/test" 
>>> con = sql.DriverManager.getConnection(url, "jyuser", "beans") 
>>> stmt = con.createStatement() 
>>> con.autoCommit = 0 
>>> try: 
...     # Insert an easy-to-find character for letter 
...     query = "INSERT INTO random (letter, number) VALUES ('.', 0)" 
...     stmt.executeUpdate(query) 
...     print "First update successful." 
...     stmt.execute("Create an exception here") 
...     con.commit() 
... except: 
...     print "Error encountered, rolling back." 
...     con.rollback() 
... 
1 
First update successful. 
Error encountered, rolling back. 
>>> 
>>> # now confirm that the first update statement was in fact undone 
>>> rs = stmt.executeQuery("SELECT * FROM random WHERE letter='.'") 
>>> rs.next() 
0 

Jython数据库编程全解析

zxJDBC

虽然使用Jython进行JDBC编程很有价值，它能在Jython中进行原型开发并利用JDBC技能，但Java类型特有的众多方法表明它是一个Java API。Java和数据库（包括JDBC）类型丰富，而这与Jython的高级、多态动态类型相悖。

Python有一个数据库API，即Python DB API，当前版本为2.0。它是CPython与数据库交互的标准API，但CPython使用的数据库驱动程序由于底层C实现，对Jython往往无用。为填补Jython缺少Python DB API的Java实现这一空白，Brian Zimmer编写了zxJDBC。实际上，zxJDBC不仅实现了DB API，还对其进行了扩展。Brian的zxJDBC工具可免费获取，包含源代码，文档完善，可从 http://sourceforge.net/projects/zxjdbc/ 或 http://www.ziclix.com/zxjdbc/ 下载。在你阅读本文时，zxJDBC工具可能已被集成到Jython中，若未集成，则需下载zxJDBC，并将 zxJDBC.jar 文件添加到类路径中。

连接数据库

使用zxJDBC包时，在调用连接函数之前，只需确保 zxJDBC.jar 和所需的JDBC驱动程序在类路径中即可。创建数据库连接的实际驱动加载操作会在后台完成。使用zxJDBC建立数据库连接有以下两个步骤：
1. 将适当的驱动程序和 zxJDBC.jar 文件包含在类路径中。
2. 向 zxJDBC.connect() 方法提供JDBC URL、用户名、密码和数据库驱动程序类的名称。

以下是使用zxJDBC时设置类路径的示例：

# For MySQL
set CLASSPATH=mm_mysql-2_0_4-bin.jar;\path\to\zxJDBC.jar;%CLASSPATH%
# For PostgreSQL
set CLASSPATH=\path\to\jdbc7.1-1.2.jar;\path\to\zxJDBC.jar;%CLASSPATH%

zxJDBC.connect 方法返回数据库连接，其语法如下：

zxJDBC.connect(URL, user, password, driver) -> connection

以下是使用 zxJDBC.connect 方法获取连接的示例：

from com.ziclix.python.sql import zxJDBC
mysqlConn = zxJDBC.connect("jdbc:mysql://localhost/test",
                           "jyuser", "beans",
                           "org.gjt.mm.mysql.Driver")
postgresqlConn = zxJDBC.connect("jdbc:postgresql://localhost/test",
                                "jyuser", "beans",
                                "org.postgresql.Driver")

驱动程序所需的特殊参数可以作为关键字参数传递给 connect 函数。例如，在连接MySQL数据库时将 autoReconnect 设置为 true ：

url = "jdbc:mysql://localhost/test"
user = "jyuser"
password = "beans"
driver = "org.gjt.mm.mysql.Driver"
mysqlConn = zxJDBC.connect(url, user, password, driver,
                           autoReconnect="true")

连接错误会引发 DatabaseError 异常，处理连接尝试中的错误需要使用 except 语句，示例如下：

url = "jdbc:mysql://localhost/test"
user = "jyuser"
password = "beans"
driver = "org.gjt.mm.mysql.Driver"
try:
    mysqlConn = zxJDBC.connect(url, user, password, driver,
                               autoReconnect="true")
except zxJDBC.DatabaseError:
    pass
    #handle error here

如果你使用 javax.sql 包中的连接工厂，或实现 javax.sql.DataSource 或 javax.sql.ConnectionPoolDataSource 的类，可以使用 zxJDBC.connectx 方法。需要注意的是， javax.sql 包在普通JDK安装中不包含，企业版除外。MySQL JDBC驱动包含 MysqlDataSource 类，以下是使用 zxJDBC.connectx 方法的示例：

from com.ziclix.python.sql import zxJDBC
userInfo = {'user':'jyuser', 'password':'beans'}
con = zxJDBC.connectx("org.gjt.mm.mysql.MysqlDataSource",
                      serverName='localhost', databaseName='test',
                      port=3306, **userInfo)

也可以将bean属性名包含在包含用户名和密码信息的字典中：

from com.ziclix.python.sql import zxJDBC
userInfo = {'user':'jyuser', 'password':'beans',
            'databaseName':'test', 'serverName':'localhost',
            'port':3306}
con = zxJDBC.connectx("org.gjt.mm.mysql.MysqlDataSource" , **userInfo)

还可以通过JNDI查找使用 zxJDBC.lookup 方法获取连接，该方法只需要一个表示绑定到特定连接或 DataSource 的JNDI名称的字符串。关键字参数可以包含在内，当关键字与 javax.jndi.Context 的静态字段名称匹配时，会转换为该静态字段的值。

游标

zxJDBC游标是用于实际与数据库中的数据进行交互的对象，它实际上是JDBC Statement和ResultSet对象的包装器。静态和动态游标类型的区别在于对结果集的处理方式。动态游标是惰性的，仅在需要时遍历结果集，这样可以节省内存并均匀分配处理时间。静态游标不是惰性的，它会立即遍历整个结果集，因此会产生内存开销。静态游标的优点是在执行语句后不久就能知道行数，而使用动态游标时无法做到这一点。

要获取游标，可以调用zxJDBC连接对象的 cursor() 方法。以下是连接数据库并获取游标对象的示例：

from com.ziclix.python.sql import zxJDBC
url = "jdbc:mysql://localhost/test"
user = "jyuser"
password = "beans"
driver = "org.gjt.mm.mysql.Driver"
con = zxJDBC.connect(url, user, password, driver,
                        autoReconnect="true")
cursor = con.cursor() # Static cursor
# Alternatively, you can create a dynamic cursor
cursor = con.cursor(1) # Optional boolean arg for dynamic

游标对象的 execute 方法用于执行SQL语句。以下是执行一个选择 random 表中所有数据的SQL语句的示例：

>>> from com.ziclix.python.sql import zxJDBC
>>> url = "jdbc:mysql://localhost/test"
>>> user, password, driver = "jyuser", "beans", "org.gjt.mm.mysql.Driver"
>>> con = zxJDBC.connection(url, user, password, driver)
>>> cursor = con.cursor()
>>> cursor.execute("SELECT * FROM random")

要遍历语句的结果，需要使用游标的 fetchone 、 fetchmany 和 fetchall 方法。 fetchone 和 fetchall 方法的功能如其名称所示，分别获取一个结果集行或获取所有行。 fetchmany 方法接受一个可选参数，用于指定返回的行数。每次返回多行时，它们以序列的序列（元组列表）形式返回。以下是继续上述示例展示这三个方法的使用：

>>> cursor.fetchone()
(41, 'O', 1)
>>> cursor.fetchmany()
[(6, 'f', 2)]
>>> cursor.fetchmany(4)
[(49, 'W', 4), (35, 'I', 5), (43, 'Q', 6), (37, 'K', 3)]
>>> cursor.fetchall() # All remaining in this case
[(3, 'c', 7), (17, 'q', 8), (29, 'C', 9), (36, 'J', 10), (43, 'Q', 11), (23,
'w', 12), (49, 'W', 13), (25, 'y', 14), (40, 'N', 15), (50, 'X', 16), (46,
'T', 17), (51, 'Y', 18), (8, 'h', 19), (25, 'y', 20), (7, 'g', 21), (11, 'k',
22), (1, 'a', 23)]

查询执行后，可以使用游标的 description 属性查看结果集中那些行的行信息。 description 属性是只读的，包含结果集中每行的一个序列，每个序列包含列的名称、类型、显示大小、内部大小、精度、比例和可空性信息。上述查询的描述如下：

>>> cursor.description
[('number', -6, 4, None, None, None, 1), ('letter', 1, 1, None, None, None,
1), ('pkey', 4, 10, None, 10, 0, 0)]

以下是游标对象的主要方法和属性列表：
| 方法/属性 | 描述 |
| — | — |
| description | 描述查询结果中每列的信息，包含名称、类型代码、显示大小、内部大小、精度、比例和可空性等七项信息的元组。 |
| rowcount | 结果集中的行数，仅在游标为静态游标或使用动态游标完全遍历结果集后有效。 |
| callproc(procedureName, [parameters]) | 调用存储过程，仅适用于实现了存储过程的数据库。 |
| close() | 关闭游标。 |
| execute(statement) | 执行SQL语句。 |
| executemany(statement, parameterList) | 使用参数列表执行SQL语句，可以在SQL语句中使用问号表示值，并在 parameterList 中提供值的元组来替换问号。 |
| fetchone() | 获取查询结果的一行。 |
| fetchmany([size]) | 如果没有提供参数，则返回 arraysize 数量的行；如果提供了参数 arg ，则返回 arg 数量的结果行。 |
| fetchall() | 获取所有剩余的结果行。 |
| nextset() | 继续处理下一个结果集，仅适用于支持多个结果集的数据库。 |
| arraysize | fetchmany() 方法在没有参数时应返回的行数。 |

zxJDBC和元数据

Python DB API不包含元数据规范，但zxJDBC通过一些连接和游标属性提供了一些连接元数据，这些属性与本章前面讨论的JDBC java.sql.DatabaseMetaData 对象中的bean属性相匹配。以下是zxJDBC游标字段和底层DatabaseMetaData bean方法的对应关系：
| zxJDBC属性 | DatabaseMetaData访问器 |
| — | — |
| connection.dbname | getDatabaseProductName |
| connection.dbversion | getDatabaseProductVersion |
| cursor.tables(catalog, schemapattern, tablepattern, types) | getTables |
| cursor.columns(catalog, schemapattern, tablenamepattern, columnnamepattern) | getColumns |
| cursor.foreignkeys(primarycatalog, primaryschema, pimarytable, foreigncatalog, foreignschema, foreigntable) | getCrossReference |
| cursor.primarykeys(catalog, schema, table) | getPrimaryKeys |
| cursor.procedures(catalog, schemapattern, procedurepattern) | getProcedures |
| cursor.procedurecolumns(catalog, schemapattern, procedurepattern, columnpattern) | getProcedureColumns |
| cursor.statistics(catalog, schema, table, unique, approximation) | getIndexInfo |

以下是从之前创建的MySQL random 数据库中提取一些元数据的示例：

>>> from com.ziclix.python.sql import zxJDBC
>>> url = "jdbc:mysql://localhost/test"
>>> driver = "org.gjt.mm.mysql.Driver"
>>> dbconn = zxJDBC.connect(url, "jyuser", "beans", driver)
>>> dbconn.dbname
'MySQL'
>>> dbconn.dbversion
'3.23.32'

其余元数据可通过游标对象访问。当游标检索信息时，它会将其存储在内部，等待用户提取。要查看游标提供的元数据，必须先调用每个元数据方法，然后使用游标检索数据：

>>> cursor.primarykeys(None, "%", "random")
>>> cursor.fetchall()
[('', '', 'random', 'pkey', 1, 'pkey')]
>>> cursor.tables(None, None, '%', None)
>>> cursor.fetchall()
[('', '', 'random', 'TABLE', '')]
>>> cursor.primarykeys('test', '%', 'random')
>>> cursor.fetchall()
[('test', '', 'random', 'pkey', 1, 'pkey')]
>>> cursor.statistics('test', '', 'random', 0, 1)
>>> cursor.fetchall()
[('test', '', 'random', 'false', '', 'PRIMARY', '3', 1, 'pkey', 'A', '23',
None, '')]

预编译语句

游标对象的 executemany() 方法类似于Java的预编译语句。实际上，其他执行的语句也会被预编译，但 executemany() 方法允许在SQL语句中使用问号表示值。 executemany() 的第二个参数是一个值的元组，用于替换SQL语句中的问号：

>>> sql = "INSERT INTO random (letter, number) VALUES (?, ?)"
>>> cur.executemany(sql, ('Z', 51))
>>>
>>> # view the row
>>> cur.execute("SELECT * from random where letter='Z'")
>>> cur.fetchall()
[('Z', 51, 24)]

错误和警告

zxJDBC中可能引发的异常如下：
- Error ：通用异常。
- DatabaseError ：针对特定数据库错误抛出，连接对象和所有连接方法（ connect 、 lookup 、 connectx ）可能会引发此异常。
- ProgrammingError ：针对编程错误（如缺少参数、错误的SQL语句）抛出，游标对象和查找连接可能会引发此异常。
- NotSupportedError ：当方法未实现时抛出此异常。

这些异常都在zxJDBC包中， except 子句应如下所示：

>>> try:
...     pass #Assume a method that raises and error is here
... except zxJDBC.DatabaseError:
...     pass # Handle DatabaseError
... except zxJDBC.ProgrammingError:
...     pass # handle ProgrammingError
... except notSupportedError:
...     pass # handle not supported error
... except zxJDBC.Error:
...     pass # Handle the generic Error exception

还可以使用游标的 warnings 属性获取警告信息。如果没有警告，则 cursor.warnings 属性为 None 。

dbexts

zxJDBC包的另一个扩展是 dbexts ，它是一个Python模块，在Python DB API 2.0之上添加了另一层抽象。使用 DBexts ，可以在配置文件中指定连接信息，然后对定义的连接使用更高级的 dbexts 方法。要使用 dbexts ，需要将 zxJDBC 附带的 dbexts.py 模块添加到 sys.path 中。

配置文件可以是任何文件，默认是与 dbexts.py 文件位于同一目录下的 dbexts.ini 文件。若要使用其他文件，可在 dbexts 构造函数中包含文件名。以下是一个配置文件示例，定义了与本章中使用的两个数据库的连接：

[default]
name=mysqltest
[jdbc]
name=mysqltest
url=jdbc:mysql://localhost/test
user=jyuser
pwd=beans
driver=org.gjt.mm.mysql.Driver
[jdbc]
name=pstest
url=jdbc:postgresql://localhost/test
user=jyuser
pwd=beans
driver=org.postgresql.Driver

配置文件定义好后，可以通过实例化 dbexts 类来连接数据库。以下示例中， dbexts.ini 文件放在当前工作目录中，也可以将其放在 sys.path 中放置 dbexts.py 模块的目录中：

>>> from dbexts import dbexts
>>> mysqlcon = dbexts("mysqltest", "dbexts.ini")
>>> psgrscon = dbexts("pstest", "dbexts.ini")
>>>
>>> # execute raw sql and get a list of headers and results
>>> psgrscon.raw("SELECT * from random")
([('letter', 1, 1, None, None, None, 1), ('number', 4, 11, None, 10, 0, 1)],
[('A', 4), ('f', 6), ('a', 1)])
>>>
>>> # execute interactive sql
>>> psgrscon.isql("select * from random")
LETTER | NUMBER
---------------
A      | 4
f      | 6
a      | 1
3 rows affected
>>>
>>> # Display schema- this works with postgresql, not MySQL
>>> psgrscon.schema("random")
Table
random
Primary Keys
Imported (Foreign) Keys
Columns
letter                 bpchar(1), nullable
number                 int4(4), nullable
Indices
>>>
>>> # show tables in MySQL 'test' database
>>> mysqlcon.table()
TABLE_CAT | TABLE_SCHEM | TABLE_NAME | TABLE_TYPE | REMARKS
-----------------------------------------------------------
          |             | random     | TABLE      |
1 row affected

以下是 dbexts 的主要方法列表：
| 方法 | 描述 |
| — | — |
| __init__(dbname, cfg, resultformatter, autocommit) | dbexts 构造函数，所有参数都有默认值，因此都是可选的。 dbname 是在 dbexts.ini 文件中为连接指定的名称。 cfg 是 dbexts.ini 文件的位置，如果它不在 dbexts.py 文件所在的目录中。 resultformatter 是一个可调用对象，接受一个行列表作为一个参数，并可选地接受一个头列表，用于显示数据。 autocommit 参数默认设置为 1 （即 true ），但在调用构造函数时可以设置为 0 。 |
| isql(sql, params, bindings, maxrows) | 交互式执行SQL语句，意味着执行语句后会立即使用 resultformatter 显示结果，类似于MySQL和pSQL客户端程序。除了 sql 语句外，所有参数都有默认值。 sql 参数是SQL语句本身。 params 参数是用于替换SQL语句中 ? 的值参数元组。 bindings 参数允许绑定一个数据处理程序，有关数据处理程序的更多信息，请参阅 zxJDBC 的文档。 maxrows 指定返回的最大行数，零或 None 表示无限制。 |
| raw(sql, params, bindings) | 执行SQL语句并返回一个包含头和结果的元组。 params 和 bindings 参数与 isql 方法相同。 |
| schema(table, full, sort) | 显示表的索引、外键、主键和列。如果 full 参数不为零，结果将包括表的引用键。 sort 值不为零表示表的列名将被排序。 |
| table(table) | table 参数是可选的。如果没有提供表参数，此方法将显示所有表的列表；否则，将显示指定表的列。 |
| proc(proc) | proc 参数是可选的。如果没有参数，将列出所有过程；如果有参数，将显示指定过程的参数。 |
| bcp(src, table, where='(1=1)') | 此方法将数据从指定的数据库和表（ src 和 table ）复制到当前实例的数据库。 |
| begin(self) | 创建一个新的游标。 |
| rollback(self) | 回滚自创建新游标以来执行的语句。 |
| commit(self, cursor=None, maxrows=None) | 提交自创建新游标以来执行的语句。 |
| display(self) | 使用当前格式化程序显示结果。 |

综上所述，Jython在数据库编程方面提供了丰富的功能和多样的选择。无论是使用DBM文件进行简单的数据存储，还是通过JDBC或zxJDBC与复杂的数据库管理系统交互，都能满足不同场景的需求。通过序列化和事务处理等功能，还能进一步增强数据的存储和操作能力。掌握这些技术，能让开发者在数据库编程领域更加得心应手。