[翻译] mhss 原著：igor dayen
翻译：寒蝉退士（mhss）
译者声明：译者对译文不做任何担保，译者对译文不拥有任何权利并且不负担任何责任和义务。
原文：http://www.xml.com/pub/a/2001/06/20/databases.html介绍
解决把 xml 有效的、自动的转换出入关系数据库的问题有各种方式。数据库厂商比如 ibm、microsoft、oracle 和 sybase 已经开发了转换 xml 到数据库表中的辅助工具。各种解决方案如下。
在这篇文章中，我们将详细讨论这些厂商的解决方案。此后，我们将尝试回答下列问题：<!-- 简单类型 -->
<!element currency1 (#pcdata)>
<!attlist currency1 e-dtype nmtoken #fixed "string"
e-dsize nmtoken #fixed "3">
<!element currency2 (#pcdata)>
<!attlist currency2 e-dtype nmtoken #fixed "string"
e-dsize nmtoken #fixed "3">
<!element amount (#pcdata)>
<!attlist amount e-dtype nmtoken #fixed "decimal">
<!element settlement (#pcdata)>
<!attlist settlement e-dtype nmtoken #fixed "date">
<!element bankcode (#pcdata)>
<!attlist bankcode e-dtype nmtoken #fixed "string">
<!element bankacct (#pcdata)>
<!attlist bankacct e-dtype nmtoken #fixed "string">
<!-- 派生类型 -->
<!element account (bankcode, bankacct)>
<!element fxtrade (currency1, currency2, amount, settlement, account)>oracle xml-sql utility (xsu)
sql 到 xml 的映射
oracle 把对象引用链从数据库转换到 xml 文档的层次结构中。在对象-关系数据库，在表 fxtrade 中的字段 account 被建模为类型 accounttype 的一个对象引用:create table fxtrade
{
currency1 char (3),
currency2 char (3),
amount numeric (18,2),
settlement date,
account accounttype // 对象引用
}
create type accounttype as object
{
bankcode varchar (100),
bankacct varchar (100)
}
从给定的对象-关系模型生成相应的 xml 文档(使用 "select * from fxtrade")如下<?xml version="1.0"?>
<rowset>
<row num="1">
<currency1>gbp</currency1>
<currency2>jpy</currency2>
<amount>10000</amount>
<settlement>20010325</settlement>
<account>
<bankcode>812</bankcode>
<bankacct>00365888</bankacct>
</account>
</row>
<!-- additional rows ... -->
</rowset>
从数据库提取 xml
下面的例子取自 oracle 的 xsu 文档，带有 sql 语句的适当替换并使用 oracle 的纯 java jdbc 薄驱动程序。
首先，建立了 oraclexmlquery 的一个实例，其后，执行一个查询，并把结果表示为上面的 xml 文档的形式。类似的，可以提取 xml 文档到 dom 的形式；在这种情况下，可以调用 qry.getxmldom() 取代 getxmlstring()。import oracle.jdbc.driver.*;
import oracle.xml.sql.query.oraclexmlquery;
import java.lang.*;
import java.sql.*;
// 测试 xml 文档生成为 string 的类
class testxmlsql {
public static void main(string[] args)
{
try {
// 建立连接
connection conn = getconnection("scott", "tiger");
// 建立查询类
oraclexmlquery qry = new oraclexmlquery(conn,
"select * from fxtrade");
// 得到 xml 字符串
string str = qry.getxmlstring();
// 打印 xml 输出
system.out.println("the xml output is:/n" + str);
// 总是关闭查询来释放所有资源
qry.close();
} catch(sqlexception e) {
system.out.println(e.tostring());
}
}
// 得到给定的用户名字和口令的连接
private static connection getconnection(string username,
string password)
throws sqlexception
{
// 注册 jdbc 驱动程序
drivermanager.registerdriver(new
oracle.jdbc.driver.oracledriver());
// 建立 oci8 驱动程序的连接
connection conn =
drivermanager.getconnection(
"jdbc:oracle:thin:@dlsun489:1521:orcl",
username, password);
return conn;
}
}
存储 xml 在数据库中
在例子中使用 oraclexmlsave 来存储我们的 xml 文档到对象关系模型中；insertxml 方法进行实际的数据插入。import java.sql.*;
import oracle.xml.sql.dml.oraclexmlsave;
public class testxmlinsert
{
public static void main(string args[])
throws sqlexception
{
connection conn = getconnection("scott", "tiger");
oraclexmlsave sav = new oraclexmlsave(conn, "scott. fxtrade");
// assume that the user passes in this document as 0-arg
sav.insertxml(args[0]);
sav.close();
}
...
}
如果 xml 和在数据库中的对象-关系模型是同步的则一切正常，但是如果不同呢? 在这种情况下你有两种选择。
调整对象-关系模型 -- 可以构造一个可修改的对象-关系视图来完成多表修改；或者，作为替代，使用 xslt，可以把 xml 文档分解成一组"平坦的"子文档。xsu 不允许属性值的存储；它建议你把属性转换成元素。
oracle xsu 的总结
通过如下对象-关系模型构造规则建模 xml 到 sql 映射: 把每个嵌套的 xml 元素映射在适当的类型的一个对象引用上。映射规则被暗含的嵌入到数据库模型中。
java api 由类 oraclexmlquery 和 oraclexmlsave 组成。ibm db2 xml extender
sql 到 xml 的映射
ibm 的 xml extender 为使用 db2 作为 xml 仓库提供两种访问和存储方法:
dtd 存储在 dtd 仓库中，叫做 dtd_ref 的一个 db2 表中；它的模式名字是"db2xml"。在 dtd_ref 表中每个 dtd 都有一个唯一的 id。在数据库表和 xml 文档的结构之间的映射是通过数据访问定义(dad)文件的方式来定义的。dad 引用一个处理过的文档 dtd，从而提供在 xml 文档、它的 dtd 和在数据库表之上的映射规则之间的桥梁。
下面是一个例子 dad。<?xml version="1.0"?>
<!doctype dad system "dad.dtd">
<dad>
<dtdid>fxtrade.dtd</dtdid>
<validation>yes</validation>
<xcollection>
<prolog>?xml version="1.0"?</prolog>
<doctype>!doctype fxtrade fxtrade.dtd </doctype>
<root_node>
<element_node name="fxtrade">
<rdb_node>
<table name="fxtrade"/>
<table name="account" key="id"/>
<condition>
fxtrade.account=account.id
</condition>
</rdb_node>
<element_node name="currency1">
<text_node>
<rdb_node>
<table name="fxtrade"/>
<column name="currency1" type="char(3)"/>
</rdb_node>
</text_node>
</element_node>
<element_node name="currency2">
<text_node>
<rdb_node>
<table name="fxtrade"/>
<column name="currency2" type="char(3)"/>
</rdb_node>
</text_node>
</element_node>
<element_node name="amount">
<text_node>
<rdb_node>
<table name="fxtrade"/>
<column name="amount" type="decimal(18,2)"/>
</rdb_node>
</text_node>
</element_node>
<element_node name="settlement">
<text_node>
<rdb_node>
<table name="fxtrade"/>
<column name="settlement" type="date"/>
</rdb_node>
</text_node>
</element_node>
<element_node name="account">
<element_node name="bankcode">
<text_node>
<rdb_node>
<table name="account"/>
<column name="bankcode" type="varchar(100)"/>
</rdb_node>
</text_node>
</element_node>
<element_node name="bankacct">
<text_node>
<rdb_node>
<table name="account"/>
<column name="bankacct" type="varchar(100)"/>
</rdb_node>
</text_node>
</element_node>
</element_node> <!--end of account element-->
</element_node> <!-- end of fxtrade element -->
</root_node>
</xcollection>
</dad>
dad 通过使用 element_node 到 rdb_node 关联来定义在 xml 文档和关系数据库列之间的映射。顶层的 element_node fxtrade 被定义为在表 fxtrade 和 account 之间的连接，带有在 account 表中的字段 id 作为主键。子元素 currency1 被映射到在表 fxtrade 中的字段 currency1 上，以此类推。注意 account 元素不包含任何 rdb_node -- 这是不需要的，原因是在前面已经定义了 account 和 fxtrade 之间的连接。account、banccode 和 bankacct 的子元素分别的定义在 account 表中的对应的列中。原子 xml 元素在 dad 中标记为 text_node。在上面的例子中，除了 fxtrade 和 account 之外的所有元素都是原子的。
从数据库提取 xml
通过存储过程来处理 xml 文档的合成和分解: 存储过程 dxxgenxml() 从数据库提取 xml 文档；存储过程 dxxshredxml() 存储 xml 文档到数据库中。
dxxgenxml() 的主要输入参数是
其他输入参数指定返回行的最大数目，和 <rdb_node> <condition> 元素摒弃(override)选项。输出参数包括返回行的实际数目，返回代码，和返回消息。
在 "ibm db2 universal database xml extender administration and programming, version 7" 中的一个 c 程序内、可以找到的存储过程的一个详尽的例子。
存储 xml 在数据库中
把 xml 文档放入数据库中是通过存储过程 dxxshredxml() 来完成的。
dxxshredxml() 的输入参数是
它的输出参数是一个返回代码和返回消息。
总结
xml-sql 映射规则通过数据访问定义(dad)文件的方式来指定，它是一个 xml 文档。db2 xml extender 管理设施包括为每个持久的 dtd 构造 dad 文件的一种手段。
进一步增强将包含新的 xml-sql 转换语法，它将使用 xml 转换语言，是 w3c xslt 的一个子集。microsoft sql server 2000
sql 到 xml 的映射
sql server 的 sql-to-xml 和 xml-to-sql 映射规则使用不同的语法。在下面的提取和存储段落中讨论映射的详情。
从数据库提取 xml
在数据库列和 xml 元素或属性之间的映射通过在 select 中的 as 别名的方式来定义:
<数据库列> as [元素名字! 嵌套级别! 属性名字! 指示]
同下面一样，文档顶层被赋予级别 1。缺省的，映射列数据在属性值上。可以使用指示"element"来改变这个缺省设置。
从数据库生成 xml 的过程有两步。
步骤 1。建立到你希望输出 xml 中的原子元素的 as-别名；别名定义了在元素之间的父/子联系。下面的表展示给我们的例子文档的别名。fxtrade /* level=1 */
currency1 [fxtrade!1!currency1]
currency2 [fxtrade!1!currency2]
amount [fxtrade!1!amount]
settlement [fxtrade!1!settlement]
account /* level=2 */
bankcode [account!2!bankcode]
bankacct [account!2!bankacct]
步骤 2。在 sql 中定义输出树结构。通过 select 语句定义树的每个级别，此后通过 union all 语句的手段把各个级别组合在一起到树中。级别-1 select 语句介入在所有级别上的原子元素名字。每个 select 语句介入一个树级别标记和它的父标记。在结果集中有一个单一记录对应于树根，如同在下面的第一个 select 语句中定义的那样。select
1 as tag,
null as parent,
null as [fxtrade!1!currency1],
null as [fxtrade!1!currency2],
null as [fxtrade!1!amount],
null as [fxtrade!1!settlement],
null as [account!2!bankcode],
null as [account!2!bankacct]
from
fxtrade
union all
select
2,
1,
fxtrade.currency1,
fxtrade.currency2,
fxtrade.amount,
fxtrade.settlement,
account.bankcode,
account.bankacct
from
fxtrade, account
where
fxtrade.account = account.id
order by [account!2!bankcode],
[account!2!bankacct]
for xml explicit, elements
for xml 通过分析在组合的行集中的标记和as-别名构造 xml 文档。关键字 explicit 选择构造 xml 文档的最灵活的、用户定义的模式。另一个模式 auto 通过应用缺省规则构造 xml 文档。关键字 elements 在元素级别建模 sql 列；否则，缺省的是在属性级别建模 sql 列。
存储 xml 在数据库中
使用 openxml 存储 xml 文档，它是一个新的行集函数，类似于表或视图。可以使用 openxml 来插入或更新或 select into 目标表。openxml 简化的语法展示如下:
openxml (<xml 文档句柄>, <路径 pattern>, <标志>)
with (模式 | 表)
存储 xml 文档的过程分三步。
在下列例子中展示这些步骤。declare @idoc int
declare @doc varchar(1000)
set @doc ='
<fxtrade>
<currency1>gbp</currency1>
<currency2>jpy</currency2>
<amount>10000</amount>
<settlement>20010325</settlement>
<account>
<bankcode>812</bankcode>
<bankacct>00365888</bankacct>
</account>
</fxtrade>'
-- 建立 xml 文档的内部 dom 表示。
exec sp_xml_preparedocument @idoc output, @doc
-- 执行使用 openxml 行集提供者的一个 select 语句。
select *
from openxml (@idoc, '/fxtrade/account', 2)
with (
currency1 char (3), '../@currency1',
currency2 char (3), '../@currency2',
amount numeric (18,2), '../@amount',
settlement datetime, '../@settlement',
bankcode varchar (100), '@bankcode',
bankacct varchar (100), '@bankacct' )
exec sp_xml_removedocument @idoc
总结
对于 microsoft sql server 2000，xml 文档的提取和存档不使用对称的语法。提取通过使用 for xml 构造扩展出一个 select-子句。存储介入一个行集函数 openxml，类比于一个表或视图。提取映射规则是基于 (a)介入指定树级别用的标记和 (b) 对表的字段关联上在 xml 文档元素之间的父/子联系。存储把 xml 文档重构到一个平坦的模式或表中；使用 xpath 表示法定义 "字段-元素"关联。sybase adaptive server
sql 到 xml 的映射
sybase 使用一个 xml 文档类型 resultset 来描述 xml 文档元数据(元素名字、类型、大小等)和实际的行数据二者。下面摘录自假定的 fxtradeset.xml:<?xml version="1.0"?>
<!doctype resultset system "resultset.dtd">
<resultset>
<resultsetmetadata>
<columnmetadata
...
getcolumnlabel="currency1"
getcolumnname="currency1"
getcolumntype="12"
... />
...
</resultsetmetadata>
<resultsetdata>
<row>
<column name="currency1">gbp</column>
...
</row>
</resultsetdata>
</resultset>
resultset dtd 好像不允许嵌套元素的定义。
从数据库提取 xml
java 类 resultsetxml 有一个构造器，它接受一个 sql 查询作为参数，此后 getxmlltext 方法从结果集提取个 xml 文档:jcs.xml.resultset.resultsetxml rsx = new jcs.xml.resultset.resultsetxml
("select * from fxtrade", <other parameters>);
fileutil.string2file ("fxtradeset.xml", rsx.getxmltext());
存储 xml 在数据库中
resultsetxml 类构造器也接受一个 xml 文档作为参数。此后方法 tosqlscript 生成 sql 语句的序列来从结果集插入/更新到指定的表。string xmlstring = fileutil.file2string ("fxtradeset.xml");
jcs.xml.resultset.resultsetxml rsx = new jcs.xml.resultset.resultsetxml
(xmlstring);
string sqlstring = rsx.tosqlscript ("fxtrade", <other parameters>)
总结
xml 文档的提取和存储是本质上对称的。存储好像不允许修改多于一个表。提取把 sql 查询的结果转换到有平坦结构的文档中。厂商比较
厂商 映射规则 单一表/多个表 转化的手段 对称的提取/存储 oracle 隐含的；通过构造对象-关系模型 多个 指定的 java 类 对称，如果 xml 文档和对象-关系模型匹配 ibm 数据访问定义文件 多个 指定的存储过程 对称 microsoft sql 扩展；行集函数 多个表用于提取；单一表用于存储 通过使用 sql 构造for xml和行集openxml 不对称 sybase 结果集 dtd 单一表；查询可以包含多个表 通过使用 java 类 对称
厂商间的公共特征是:一种可替代的策略
xml 文档存储在数据库中的任务可以划分到阶段? 首先，存储 xml 在普通的数据库结构中而不应用任何映射规则；其次，为后续的处理提供一个框架? 这种方法的好处是对于事实上的任何 xml 文档有一个通用的采集代理(acquisition agent)。本文的余下部分只提议这种解决方式。
在这种策略下，xml 文档保存为正常的树结构――原始树数据――用于进一步的应用处理。进一步数据处理的框架是一组数据库对象(存储过程)，类似于 dom api，用来通过传统的 sql 处理来操纵数据。
使用与全自动方式相反的框架方式的好处有: 数据库群体(population)通常由分布在"纯"应用程序代码、事务处理、数据库层(layer)和存储过程之间的应用逻辑来控制的，不必提及一些表可能驻留在远端数据库中。
此外，在异构的数据库环境中，拥有一个统一的工具来对不同的数据库完成相同的任务有着明显的好处。
作者的解决方案，objectcentric solutions x-persistence utility，实现了这里讨论的策略。
原始树结构通过如下表来定义。
1) 树节点定义create table nodedef (
nodeid udd_id not null, // 唯一性节点 id
dimid udd_id not null, // 树种类: xml
name udd_name not null, // 节点名字
value udd_paramvalue null, // 节点值
value_type udd_type null, // 值类型
power udd_power null, // 节点树级别
isroot udd_logical not null, // 顶层节点标志
descriptor udd_descriptor null, // dom 节点类型
color udd_color null // 非正式数据
)
2) 在节点间的父-子关系create table nodelinks (
parentid udd_id not null, // 父节点
childid udd_id not null // 子节点
)用例
存储 xml 文档在数据库中需要调用 xml2sql 程序:
xml2sql <xml 文档文件名>
使用下列存储过程实现从数据库提取 xml 文档为一个树结构:
实现细节:
x-persistence utility 当前在 open finance laboratory 中用作基于 xml 的数据采集代理的核心，它是如证券管理、负债管理、风险管理等范围内的财务应用的一个可定制的集成平台。open finance laboratory 接受 fpml 作为用于利率导出的一个叙述性语言。x-persistence utility 目前用作 fpml/fra 数据采集代理。引用
oracle xml-sql utility, http://otn.oracle.com/tech/xml/oracle_xsu
ibm db2 xml extender, www.ibm.com/software/data/db2/extenders/xmlext
xml perspective. in control with for xml explicit. sql server magazine, http://msdn.mcrosoft.com/library/periodic/period01/xmlexplicit.htm
writing xml using openxml
openxml
technology preview: x-persistence utility, objectcentric solutions, inc., 2001, http://www.objcentric.com/
浏览人数：1373
闽公网安备 35060202000074号