XML Database Products:

Middleware

Copyright 2000-2009 by Ronald Bourret

WARNING!

This list has not been updated since roughly 2010. As a result, information may be out of date and products may no longer be available. If you are interested in a product whose link does not work, search for it on the Web, as product pages frequently change and products/companies are frequently sold.

Overview

Middleware is software used by data-centric applications to transfer data between XML documents and databases. It is usually lightweight, running in the same process space as the application. (For stand-alone servers that transfer data between XML documents and databases, as well as other data sources, see Data Integration Software. Most middleware accesses data in relational databases using ODBC, JDBC, or OLE DB, although some products exist for other types of databases, such as multi-valued, hierarchical, or object-oriented databases.

Products

ADO

Developer: Microsoft
URL: http://msdn.microsoft.com/en-us/library/ms681538.aspx
License: Commercial
Database type: Relational (OLE DB, ODBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2000

ADO can persist a Recordset object as an XML document. It can also open an XML document as a Recordset object. This provides a way to transfer data between XML and a database, using Recordsets as intermediate objects.

The XML document is split into two parts. The first part maps the XML in the second part to the Recordset. The second part contains the actual data in XML format. The mapping is an object- relational mapping, which is described with an annotated version of XML-Data Reduced. (Note that this uses a slightly different syntax from the annotated schemas used by Microsoft SQL Server.) One nice thing about ADO's use of XML is that a tree of nested elements is opened as a tree of nested Recordsets and vice versa.

If the Recordset contains pending updates, deletes, or inserts, these are specifically flagged in the XML document with ADO-specific tags. In the case of updates, both the original and new data are included.
Aioob XML Database Converter

Developer: Aioob Software
URL: http://www.aioob.com/xmlpage/AioobXMLD.htm
License: Commercial
Database type: Relational (ODBC)
Direction(s): Database=>XML
Entry last updated: November, 2008

Not reviewed. Appears to use a table mapping.
Alliance XML/400

Developer: Patrick Townsend & Associates
URL: http://www.patownsend.com/productDetails.php?prodId=62
License: Commercial
Database type: Relational (AS/400)
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2008

From the Web site:

"Alliance XML/400 provides a complete secure web services solution for your IBM System i. With Alliance XML/400 you can automatically translate XML documents and web data directly to your System i standard DB2 database files. When you want to create and send XML documents, Alliance reads your DB2 database files and builds an XML document for you. Then you choose the communications protocols to deliver your XML data, including HTTP or HTTPS web communications, Microsoft Web Folders (WebDAV), File Transfer Protocol (FTP), or Websphere MQ (MQSeries)."
Allora

Developer: HiT Software
URL: http://www.hitsw.com/products_servic es/xmlplatform.html
License: Commercial
Database type: Relational (ODBC, OLE DB, JDBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: January, 2003

Allora is middleware that applications call to transfer data between an XML document and a relational database. Allora can be used in three ways. First, it can be called directly to transfer data between an XML document (or DOM tree) and the database. Second, it can be called to transfer data between an XML document and the database through a SOAP interface. Third, it can be used as an XML data binding engine. In this case, users generate classes specific to the data in an XML document or database table(s). They then use these classes directly in their application. Objects of these classes can populate themselves from an XML document or database table, and can transfer their data to an XML document or database table.

Allora uses an object-relational mapping, but provides additional capabilities as well. For example, the mapping can use JavaScript or VBScript to convert data when extracting it from the database (such mappings are not reversible) or provide a constant value for an element or attribute. In addition, the mapping can be parameterized, providing more flexibility for programmatic use.

Allora provides a GUI-based mapping tool for mapping DTDs and XML Schemas to the database schema. The tool can generate XML Schemas from database schemas and vice versa. Mappings can also be built by hand using map documents. These use XML Schema documents in which simple and complex type definitions declare how the data is mapped.

Allora contains support for popular message queues (JMS and MSMQ) and has source code wizards for JBuilder, Sun One Studio, and VB. It also has support for Microsoft BizTalk Server, TEXTML Server, Oracle's JDeveloper, and XML Spy. It comes in Java (jAllora) and Windows (winAllora and winAllora Xpress) versions. winAllora Xpress is an "entry level" version that cannot be used programmatically.
Altova MapForce

Developer: Altova
URL: http://www.altova.com/products/map force/data_mapping.html
License: Commercial
Database type: Relational (ADO, ODBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: May, 2005

Altova MapForce allows users to transfer data among XML documents, relational databases, flat files, EDI (UN/EDIFACT, ANSI X12) documents. Users define mappings with a GUI tool, which then generates XSLT 1.0, XSLT 2.0, XQuery, Java, C#, or C++ code to actually transfer the data. (One- time data transfers can also be performed directly with the tool.) Each mapping can have multiple sources and targets of different types, such as combining data from an XML document and a database and mapping it to an EDI document and another database. Mappings can also include data processing functions, which can transform the data during transfer. Standard function libraries, as well as the ability to chain and build new functions, are included.

Database mappings are created by selecting top-level tables and views. MapForce recognizes table relationships and displays the resulting tables as one or more hierarchies. Mapping is then performed by connecting source and target fields. Database-specific mapping features include the action to take (select, insert, update, or delete) and whether to generate key values.
Artix Data Services

Developer: Iona
URL: http://www.iona.com/products/ar tix/data_services/welcome.htm
License: Commercial
Database type: Relational
Direction(s): Database=>XML, XML=>Database
Entry last updated: June, 2004

[Ed. -- Iona purchased Century 24 Solutions in 2007. It appears that they repackaged C24 Integration Objects as Artix Data Services. The following is a description of C24 Integration Objects and has not been rewritten for Artix Data Services, other than changing names.]

Artix Data Services is a general data binding product that supports bindings to a variety of data formats, including XML, relational databases, CSV files, and RTF.

Artix Data Services Integration Objects uses four principal concepts for generating code: structure, presentation, transport, and bindings. A structure is a model for a particular set of data. This uses a proprietary format that has very similar modeling capabilities to those found in XML Schemas. A presentation defines an external format for a set of data, such as XML, CSV, or a relational database. A transport is the way in which data is sent to and from a particular presentation, such as a file, JMS, FTP, or JDBC.

A binding binds a structure and input and output presentations. It can be used to generate code and JavaDocs for the bound items. During code generation, the structure defines what classes will be created. The input and output presentations define the source and target of the methods used to load and save data. For example, to duplicate traditional XML data binding, both the input and output presentations would be XML, so the generated classes could be populated from XML documents and serialized as XML documents. Other combinations are possible as well. For example, data could be loaded from a relational database and saved as XML, or loaded from CSV files and saved as fixed-length records. Transports generally have no effect on code generation, but are instead wrapped in a generic Source class. An exception to this is when relational databases are used, where the relational database presentation is bound to a particular database and transport, although even this can be decoupled to a certain extent.

The generated classes can be used simply as an intermediate point in a data conversion, or directly by an application. In addition, applications can use XPath to query the objects, regardless of the input presentation. This is particularly useful when the input presentation is something other than XML.

Artix Data Services can create a structure from a DTD, an XML Schema, a RELAX-NG schema, or an XML document instance; the structure can then be used to generate code. Users can define restrictions on individual fields, such as to a set of enumerated values or a range of numeric values, as well as on multiple fields. The latter is done by specifying an XPath expression that specifies a condition applying to the restricted fields -- for example, if one exists, the other must also exist --, a snippet of Java code, or a custom class that implements a restriction interface. Further customization is possible through user-written presentation and transport classes. Other features include a tool for determining the differences between two data models, such as two different versions of the same model.
ASP2XML

Developer: Stonebroom
URL: http://www.stonebroom.com/asp2xml.htm
License: Commercial
Database type: Relational (ODBC or OLE DB)
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2000

A COM object for transferring data between an XML document and an ODBC or OLE DB data source. The product models the XML document as a single table. When transferring data from the database to XML, the user specifies a single SELECT statement and the output contains ASP2XML-specific tags, which presumably may be discarded. When transferring data from XML to the database, the XML document must contain ASP2XML-specific tags, which are required for processing. The object can be used in Microsoft Active Server Pages scripts or stand-alone.
Attunity Connect

Developer: Attunity Ltd.
URL: http://www.attunity.com/attunity_connect
License: Commercial
Database type: Various, including relational and non-relational
Direction(s): Database=>XML, XML=>Database
Entry last updated: February, 2002

Attunity Connect is a heterogeneous query engine that supports bidirectional access to a large number of databases, both relational and non-relational. Supported APIs include JCA, XML, ODBC, JDBC, and ADO/OLE DB.

XML-based queries can be sent over TCP/IP, HTTP (via ISAPI or NSAPI), or Java servlets. The product uses an object-relational mapping, with the result of nested queries returned as child elements. Columns in a table can be returned as either attributes or child elements. In addition, Attunity Connect can return metadata about the columns, as well as returning binary data using Base64 or hexadecimal encoding.

Attunity Connect also has a driver for mapping fragments of an XML document to a rowset in a manner similar to the OpenXML syntax of Microsoft SQL Server. The resulting data can presumably then be treated like any other (OLE DB?) rowset, with data inserted into the database or processed by a rowset-based application.

Of interest, Attunity Connect supports two-phase commits.
Castor

Developer: exolab.org
URL: http://www.castor.org/
License: Open Source
Database type: Relational (JDBC/JDO)
Direction(s): Database=>XML, XML=>Database
Entry last updated: December, 2002

Castor is an XML data binding product. That is, it can populate Java objects from XML documents and serialize Java objects as XML. It can also transfer data between Java objects and relational databases, as well as between Java objects and LDAP.

Castor can automatically map objects that "adhere to the Java Beans design pattern". For other objects, and to map objects to the database, an XML-based mapping language is provided. This uses an object-relational mapping and supports, "one-one and one-many relation types, SQL/Java inheritance, object graph to single row mapping, and multiple column primary keys and automatic type conversion".

JDO support includes "optimistic and pessimistic locking modes, in-memory concurrency engine, and dead-lock detection," as well as "support for JTA transaction demarcation, inclusion as resource in transactional environment, and JDBC connection pooling" and caching.

Castor includes tools to generate Java classes, mappings, and validation code from an XML Schema and to generate an XML Schema from an XML instance document.
Connect XML-2-DB

Developer: Skyhawk Systems
URL: http://www.skyhawksystems.com/
License: Commercial
Database type: Relational (Oracle, SQL Server)
Direction(s): XML => Database
Entry last updated: March, 2004

Connect XML-2-DBL is Java middleware for transferring data from XML documents to SQL Server or Oracle. It uses an object-relational mapping that is described by an XML-based mapping language (slightly different languages are used for SQL Server and Oracle). The language maps complex element types to tables, simple element types and attributes to columns, and nesting to primary key / foreign key joins. Alternatively, it can map complex element types to stored procedures and simple element types and attributes to parameters. This allows users to add business logic to the processing of the data, rather than just inserting the data into the database.

The mapping language supports two useful deviations from a strict object-relational mapping:

o An element mapped to a column is not restricted to being a child of a "table" element type. Instead, it can be a descendant. Similarly, an attribute mapped to a column does not have to belong to the table element type. Instead, it can belong to a descendant of the table element type.

o Attribute values can be "propagated" to child elements. That is, if a child element type is mapped to a table, an attribute of its parent element type can be mapped to a column in that table.

Other features of the mapping language include the ability to map constants and run-time parameters to columns, support for output parameters from stored procedures, support for Oracle sequences, and the ability to insert values from the XML document into SQL Server identity columns.

Connect XML-2-DB can be called from a Java application or run directly from the command line. Run- time options include whether to commit transactions after all the data in a document is transferred to the database or after each insert, and whether to stop processing after a certain number of errors.

Connect XML-2-DB ships with the INET Gate3 JDBC 3.0 type 4 driver.
DataDirect XQuery

Developer: DataDirect Technologies
URL: http://www.datadirect.com/products/xquer y/index.ssp
License: Commercial
Database type: Relational (JDBC), XML, Web services, flat files, EDI
Direction(s): Database=>XML, XML=>Database
Entry last updated: January, 2009

DataDirect XQuery is a embedded Java XQuery engine that can query relational, XML, and flat file data sources. It consists of a Mediator that analyzes the query and breaks it into one or more pieces, depending on the source of the data. Pieces that query relational sources are passed to the SQL Adaptor; pieces that query XML documents and Web services are passed to the XML Streaming Adaptor; and pieces that query flat files are passed to the XML Converters. The adaptors/converters return results to the Mediator, which assembles them into the final query result.

The SQL Adaptor accesses data via DataDirect JDBC drivers. For the purposes of the query, relational tables are viewed virtual XML documents via either of the mappings defined in SQL/XML, which is a standard set of extensions to SQL for constructing XML from relational data. The default mapping treats each table as a forest of elements, with one element per row and child elements for each column. The other option is to treat each table as a single document, with a single root element corresponding to the table, one row element per row in the table, and grandchild elements for each column.

The XML Streaming Adaptor accesses data via the ftp:, http:, and file: URI schemes, as well as in DOM trees. It operates via streaming and summarizes (indexes?) data on the fly, allowing it to process documents that are larger than available memory. Flat files are queried via XML Converters (sold separately), which map data to XML. Converters are available for a number of flat file formats, including EDI (Edifact, X12, and other dialects), dBase, RTF, CSV, HTML, and JSON.

Updates are performed with the XQuery Update Facility (XUF). XML documents (and flat files?) are updated directly by XUF expressions. Relational databases are updated by the ddtek:sql-insert, ddtek:sql-update, and ddtek:sql-delete updating functions, which are extensions to XUF.

Applications call DataDirect XQuery through the XQuery API for Java (XQJ) or Web services (HTTP GET, HTTP POST, SOAP). DataDirect XQuery supports calls to Java methods and SQL functions (stored procedures) and provides a Java function for invoking Web services. It can be used with the Stylus Studio and oXygen IDEs. When DataDirect XQuery, Stylus Studio, and the XML Converters are bundled together, they are called the DataDirect Data Integration Suite.
dbsql2xml

Developer: Stepan RYBAR
URL: http://dbsql2xml.sourceforge.net/
License: Open Source
Database type: Relational (JDBC)
Direction(s): Database=>XML
Entry last updated: May, 2005

dbsql2xml is a Java class for exporting relational data as hierarchical XML. The XML document can be returned as a file, a string, a DOM document, or to System.out. dbsql2xml uses a simple, XML- based mapping language to define an object-relational mapping from the relational schema to the XML schema. The language also allows users to insert a processing instruction to invoke a CSS or XSLT stylesheet. Note that this instruction would be processed outside of dbsql2xml, such as in a browser.
DbToXml

Developer: SoftRUs
URL: http://www.soft-r- us.com/dbtoxml.asp
License: Commercial
Database type: Relational (ODBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: February, 2003

DbToXml is an XML data binding product that uses a table-based mapping. Unlike most XML data binding products, it generates code from a database schema instead of an XML schema. From a single table it can generate a VB COM object or a Java Bean. The table must have a single-column primary key, although the generated code is easily modifiable to support multi-column keys. DbToXml can also generate XML Schemas, BizTalk Schemas, DTDs, sample XML documents, and SQL scripts for inserting, updating, and deleting data.

The generated COM or Java object can populate itself from the database or an XML document and can store its data in the database or an XML document. It can also update or delete data in the database.

DbToXml comes with a GUI-based tool for generating code and configuring the product.
DBIx::XML::DataLoader

Developer: Christopher Berning
URL: http://search.cpan.org/~cberning/DBIx-XML-DataLoader-1.1b/DataLoader.pm
License: Open Source
Database type: Relational (DBI)
Direction(s): XML=>Database
Entry last updated: December, 2008

DBIx::XML::DataLoader is a PERL module for transferring data from an XML document to a database. It uses a mapping file to specify how the data should be transferred. The map file uses XPath to identify an element corresponding to a table and to identify other elements corresponding to columns in that table. It is not clear if a single map file can map data to only one table or to multiple tables. The map file can also identify PERL routines to call before or after processing the data for a given table, as well as before or after individual elements.

DBIx::XML::DataLoader can insert, update, or insert-or-update data. (Insert-or-update means to first attempt to insert the data. If a row with the same key alreadys exists, DBIx::XML::DataLoader will update that row using the new data.) It can also generate a text file that can be used with Oracle's SQL*Loader utility.
DBIx::XMLMessage

Developer: Andrei Nossov
URL: http://search.cpan.org/~andrein/DBIx-XMLMessage-0.05/XMLMessage.pm
License: Open Source
Database type: Relational (DBI)
Direction(s): Database=>XML, XML=>Database
Entry last updated: May, 2002

A PERL module for transferring data between XML and databases using DBI. The product uses an object-relational mapping and includes an XML-based mapping language. Interesting features include insert, update, and insert-or-update semantics, user-specified key generation routines (in SQL or PERL), user-specified filters (database to XML), the ability to transform data values with arbitrary PERL functions, the ability to specify column defaults, and support for stored procedures (Sybase and SQL Server only).
DBIx::XML_RDB

Developer: Matt Sergeant
URL: http://search.cpan.org/~msergeant/DBIx-XML_RDB-0.05/XML_RDB.pm
License: Open Source
Database type: Relational (DBI)
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2000

A PERL module for transferring data between XML and DBI databases. The product models the XML document as a set of tables. The package includes a data transfer module and two utilities -- one for exporting data and one for importing data -- as well as a "Win32 OLE wrapper" (COM object?) allowing you to call the module from any application that supports OLE (COM?). Of interest, the module supports the transfer of binary data, encoded as UTF-8.

Note that this module has been replaced by XML::Generator::DBI.
DBIx::XMLServer

Developer: Martin Bright
URL: http://search.cpan.org/dist/DBIx-XMLServer/XMLServer.pm
License: Open Source
Database type: Relational (DBI)
Direction(s): Database=>XML
Entry last updated: March, 2004

A PERL module for transferring data from the database to XML in response to an HTTP request. It is designed to run on the server and uses DBI to access the database.

Associated with each XMLServer object is a template document. A template document specifies how data is to be retrieved and formatted as XML. The template document contains table declarations, type declarations, and one or more actual templates. The table declarations specify the tables to be used and how to join them. The type declarations specify PERL objects that are used to convert HTTP query strings into SQL conditions, result set values into XML nodes, and so on. These are used to process the values associated with a particular field (see below).

The templates specify how to convert the result of a query to XML. They consist of a skeleton of user-defined elements, a <record> element, and one or more <field> elements. The user-defined elements are copied directly to the output XML document. The <record> element delineates a section of the template that will be repeated for each row in the result set. The <field> elements are descendants of the <record> element and specify where the data for a particular column in the result set is to be placed.

DBIx::XMLServer accepts a query and an optional template element. The query is a series of conditions that are used to build a WHERE clause. It can also restrict the fields that are returned and specify the number of pages and page to return. The template element is needed when the template document contains more than one template; it specifies which template to use.

In response to a query, DBIx::XMLServer parses the query and builds a WHERE clause. It then locates the template to be used and, if the user restricted the fields that are to be returned, trims it as necessary. Finally, it builds a SELECT statement, executes it, and builds an XML document according to the template.
DB/XML Transform

Developer: IBM
URL: http://www.treehouse.com/DBXMLTransform.shtml
License: Commercial
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: June, 2006

DB/XML Transform is middleware for performing bi-directional data transfers between relational databases, XML documents, text files, and EDI (EDIFACT and X12) in any combination. It provides a GUI-based mapping tool and supports XML Schemas, BizTalk schemas, and RosettaNet schemas. It can be run through the GUI, an API, the command line, or in batch mode.

DB/XML Transform uses XPath expressions to map between source and target data and can perform "cross-level object mapping". (The latter presumably means that, when the source and target are viewed as hierarchies of objects, fields from a source object can be mapped to fields at a different level in the target hierarchy.) The map can specify different names for source and target fields, as well as whether a field is mapped to an element or attribute when the target is XML.

During data transfer, DB/XML Transform can transform data values in a number of ways. It can modify values (using standard XPath functions or built-in DB/XML Transform functions), assign fixed or dynamic default values, apply formatting rules, or generate unique values for use as keys in the database. More complex tasks, such as validating data or translating data based on lookup tables, can be performed by user-written Java objects.

DB/XML Transform also supports Tree-Structured Queries, which allow users to construct hierarchical (deeply nested) XML from relational data. They also allow the database to be updated using the data in an XML document.

[Ed. -- In 2007, IBM bought DataMirror, which developed DB/XML Transform. Although IBM does not appear to directly sell DB/XML Transform, it is still available through Treehouse Software, which has a 2005 agreement to sell DataMirror software.]

Developer: Treehouse Software
URL: http://www.treehouse.com/dpsxlnk.shtml
License: Commercial
Database type: Adabas
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2008

DPS X-Link is middleware for transfering data between XML documents and Adabas databases. It consists of a server and servlets (which run on the mainframe), a remote API module (which runs on the client), and a local API module (which runs on the mainframe).

At design time, users register the Adabas databases (files) that are to be accessed by DPS X-Link. They can also call the getXSD servlet to retrieve either of two XML Schema documents. These are built from the Adabase and Predict metadata and describe the XML documents used to submit queries and the XML documents returned by those queries. (Of note, the structure of the XML documents created for a particular Adabas database is based on the schema of that database and cannot be modified by the user.)

At run time, DPS X-Link can be used from applications that run on remote clients (which run on Unix or Windows) or local clients (which run on the mainframe). Remote clients access DPS X-Link through the remote API module, which supports SOAP, COM, DLL, and Java APIs. Local clients access DPS X- Link through the local API module, which has a C/C++ API. In either case, the client submits the name of the servlet to use, such as getXSD or getXML, the query, and any additional information needed by the servlet. The servlet executes the query against the database, formats the results (if any) as XML, and returns them to the client.

Queries may be submitted as XML documents or Adabas queries; select, insert, update, and delete queries are supported. In the case of insert, update, and delete queries, the client also submits an XML document containing the data to insert, update, or delete.

When used remotely, DPS X-Link encrypts both requests and responses. Servlet security can be based on user name and password, location (IP address or subnet), or both. In addition, servlets can be individually enabled or disabled. When used locally, encryption and servlet security are not supported, as the server and servlet are run in the address space of the client.

In addition to the servlets supplied with DPS X-Link, users can write their own servlets. For example, these could be used to access non-Adabas data. Custom servlets are responsible for all processing, such as parsing queries, submitting them to a database, and formatting results as XML.

DPS X-Link comes with a GUI-based administration tool.
Easysoft XML-ODBC Server

Developer: Easysoft
URL: http://www.easysoft. com/products/data_access/xml_odbc_server/index.html
License: Commercial
Database type: Relational (ODBC)
Direction(s): Database=>XML
Entry last updated: July, 2002

The Easysoft XML-ODBC Server allows client applications to access ODBC databases using TCP/IP. The application sends an XML document which contains an SQL statement and other information (such as connection information) to the server. The server connects to the database and executes the statement. In the case of a SELECT statement, it returns the results, formatted as XML. (For UPDATE, INSERT, and DELETE statements, it appears that an XML document containing the SQLSTATE is returned.)

When returning result sets as XML, the product uses a table-based mapping and supports three different XML formats. The "Long" format returns data using Row and Column elements, with the name of each column listed as an attribute on each Column element. The "Short" format also uses Row and Column elements, but returns all of the column names in a Columns element at the start of the document. The "TableTags" format uses cursor (table) and column names in place of the Row and Column elements. Additional options allow users to specify an XSLT stylesheet, specify the output format of binary data (ignore, hexadecimal digits, Base64), and so on.

Although the Easysoft XML-ODBC Server cannot transfer data from an XML document to the database, the application can pass INSERT, UPDATE, and DELETE statements to the database for execution.
EMS Data Import and Export

Developer: EMS
URL: http://www.sqlmanager.net/
License: Commercial
Database type: Relational
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2008

Not reviewed.
Extreme Translator

Developer: Etasoft
URL: http://www.xtranslator.com/et.htm
License: Commercial
Database type: Relational (ODBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: February, 2002

Extreme Translator is a suite of tools to transfer data between a variety of formats (XML, EDI, text, relational databases, etc.). It can be run from the command line, as an ActiveX component, or as a server.

Mapping between XML and the database is done with a graphical mapping tool. At a minimum, object- relational mappings appear to be supported. It appears that more complex mappings are possible as well. XML Schemas can be used to generate maps when transferring data from an XML document to the database.
Hibernate

Developer: Red Hat
URL: http://www.hibernate.org/hib_do cs/reference/en/html/xml.html
License: Open Source
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2008

Hibernate is middleware that provides object-relational persistence of Java objects. An experimental feature allows relational data to be mapped to XML documents using the same language used to map Java classes to the database schema. (In fact, a single map can specify the mapping from both a Java class and an XML schema to the database.)

Hibernate works with XML documents as dom4j trees. That is, when data is extracted from the database, Hibernate creates a dom4j tree. Similarly, Hibernate can store the data in a dom4j tree (created, for example, from the database or by parsing an XML document) in the database. Persistence options include saving, saving or updating, deleting, and replicating.
Hyperjaxb

Developer: Aleksei Valikov
URL: https://hyperjaxb2.dev.java.net/
License: Open Source
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: May, 2006

Hyperjaxb combines JAXB, a XML data binding package, with Hibernate, an object-relational persistence and query package. What Hyperjaxb adds to these two packages is the ability to generate Hibernate mappings from XML Schemas. These map the classes generated by JAXB to tables and columns in the database.

Hyperjaxb is used at design time via an Ant task. This task uses JAXB to generate classes from an XML Schema, the Hyperjaxb add-on to JAXB to generate Hibernate mappings, and Hibernate to generate the database schema. At run time, applications use JAXB and Hibernate directly. For example, they use Hibernate to query the database and populate objects and JAXB to serialize the object data as XML.

Users can customize how Hyperjaxb will generate the Hibernate mappings, which in turn controls how Hibernate will generate the database schema. For example, users can provide table and column names, specify data types, identify primary and foreign key fields, specify whether to ignore certain classes or fields, and so on. Customization information is specified either as annotations in the XML Schema document or in an external binding declaration document.
JaxMe

Developer: Jochen Wiedmann / Apache Software Foundation
URL: http://ws.apache.org/jaxme/
License: Open Source
Database type: Relational (JDBC), native XML (Tamino, XML:DB)
Direction(s): Database=>XML, XML=>Database
Entry last updated: March, 2004

From the Web site:

"JaxMe 2 is an open source implementation of JAXB, the specification for Java/XML binding."

"A Java/XML binding compiler takes as input a schema description (in most cases an XML schema, but it may be a DTD, a RelaxNG schema, a Java class inspected via reflection, or a database schema). The output is a set of Java classes:
o A Java bean class matching the schema description. (If the schema was obtained via Java reflection, the original Java bean class.)
o Read a conforming XML document and convert it into the equivalent Java bean.
o Vice versa, marshal the Java bean back into the original XML document."

"In the case of JaxMe, the generated classes may also:
o Store the Java bean into a database. Preferrably an XML database like eXist, Xindice, or Tamino, but it may also be a relational database like MySQL. (If the schema is sufficiently simple. :-)
o Query the database for bean instances.
o Implement an EJB entity or session bean with the same abilities."

From another part of the Web site:

"JaxMe Persistence Management means the ability to read JaxMe objects from, insert them into, update them in, or delete them from the database. These operations are supported by JaxMe's persistence managers..."

"o Relational databases via JDBC; the JaxMeJdbcSG [class] may be used to read an existing database schema via JDBC metadata and converts the tables into JaxMe objects. For any table, it also creates a specific persistence manager, which is a subclass of PMJdbcImpl."

"o Native XML databases via XML:DB, a database independent API, much like JDBC... The most important difference between native XML and relational databases is, that the former have no limitations on the structure of XML documents being stored. As a consequence, there is no need for specific support in the schema and XmlDbPM, the persistence manager for XML:DB, is generic."

"o Native XML databases via proprietary APIs or protocols; currently this only includes Tamino via the InoManager [class]."
mysql, mysqldump

Developer: MySQL
URL: http://dev.mysql.com/doc/refman/5.0/en/mysql-command-options.html
http://dev.mysql.com/doc/refman/5.0/en /mysqldump.html
License: Open Source
Database type: Relational (MySQL)
Direction(s): Database=>XML
Entry last updated: November, 2008

mysql is a command line utility for executing queries against a MySQL database. The -xml option specifies that the output is returned as XML, using the predefined element names resultset, row, and field.

mysqldump is a command line utility for dumping data from MySQL databases. It allows users to specify which tables to dump and to specify a where clause to restrict the rows that are dumped. The -xml option specifies that the output is returned as XML, using predefined elements that provide table schemas (table_structure, field, key, options) and data (table_data, row, field).

Both utilities send results to stdout.
ODBC2XML

Developer: Intelligent Systems Research
URL: http://www.intsysr.com/odbc2xml.htm
License: Shareware
Database type: Relational (ODBC)
Direction(s): Database=>XML
Entry last updated: November, 2000

A Windows DLL (which may be run through a command-line application) for transferring data from an ODBC database to an XML document. The product uses templates, with SELECT statements embedded in a template as processing instructions. It is quite flexible, as the results of embedded queries can be placed directly in elements or attributes or used to feed additional queries, which allows deeply nested XML documents to be created.
ODBC Socket Server

Developer: Team FXML
URL: http://odbcsock.sourceforge.net/
License: Open Source
Database type: Relational (ODBC, OLE DB)
Direction(s): Database=>XML
Entry last updated: November, 2000

A server for accessing any ODBC or OLE DB database via the Internet, using XML over TCP/IP. The product models the XML document as a set of tables. Clients send requests to the server in the form of a connection string and an SQL statement. Data is returned as an XML document with <row> and <column> elements. It can also be formatted according to the DTD used by ADO to represent data. ODBC Socket Server comes with utilities so it can easily be used from COM/VB, Perl, C++, and PHP.
Oracle XML Developer's Kit (XDK)

Developer: Oracle
URL: http://www.oracle.com/technology/tech /xml/xdkhome.html
License: Free
Database type: Relational (JDBC)
Direction(s) : Database=>XML (both), XML=>Database (XML SQL Utility only)
Entry last updated: February, 2002

The Oracle XML Developer's Kit is a set of tools for working with XML. It includes two XML / database tools:

  • The XML SQL Utility is a set of Java classes for transferring data between a relational database and an XML document. These classes may be used through one of the provided front ends or in a user-written application. If the database supports SQL 3 object views, the product uses an object-relational mapping; otherwise it uses a table-based mapping for a single table. When transferring data from the database to XML, the user provides either a SELECT statement or a JDBC result set; the results are returned as an XML document, a DOM Document, or SAX2 events and may optionally include an inline XML Schema. When transferring data from XML to the database, the user provides an XML document or DOM Document. Options include specifying some of the tags used in the output document. The XML SQL Utility also supports updates and deletes.

  • The XSQL Servlet is a Java servlet that uses the XML SQL Utility for Java to transfer data from a relational database to an XML document. The servlet uses templates, with SELECT statements embedded in the template as <query> elements; when processed, these are replaced by the result of the query, formatted as XML. Support for passing query parameters through HTTP and for processing the output document with XSL are provided.

Oracle XML Query Service

Developer: Oracle
URL: http://www.oracle.com/technology/te ch/xml/xds/index.html
License: Free
Database type: Relational, applications (SAP, PeopleSoft, etc.), Web Services, flat files
Direction(s) : Database=>XML
Entry last updated: December, 2008

Oracle XML Query Service (formerly known as Oracle XML Data Synthesis (XDS)) is a heterogenous join engine that uses XQuery as its query language. Data sources are mapped to virtual XML documents and these documents are queried using XQuery. Queries can be saved as views, which can then be accessed from other queries.

Oracle XML Query Service supports JSR 225 (XQJ) and can be called from Java classes, Java Server Pages (JSP), or Web Services.
Osage

Developer: George Stewart, et al
URL: http://osage.sourceforge.net/
License: Open Source
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: February, 2002

Osage is primarily an object-relational engine. It includes facilities for marshalling objects to/from XML and therefore can be used to transfer data between XML documents and databases via the intermediate objects.

To use Osage, users write documents that map classes to the database. These documents also specify the relationships between objects and how these relationships are mapped to the database. They then use a tool to generate the corresponding classes, which can be used within the Osage framework. (Maps can also be generated directly from the database using another tool.)

Transferring data from XML to the database requires two steps: unmarshalling the data from an XML document to an object, and saving the object in the database. Transferring data from the database to XML reverses the process.
RefleX

Developer: Phillipe Poulard
URL: http://reflex.gforge.inria.fr/
License: Open Source
Database type: Relational (JDBC)
Direction(s): Database => XML
Entry last updated: November, 2008

RefleX is an implementation of INRIA's Active Tags technology, which allows users to write applications using an XML-based programming language. For example, the language includes tags for branching, looping, variable assignment, and parsing, traversing, and manipulating XML documents. The RefleX engine reads the Active Tags document and performs the actions specified by the tags. The language is arbitrarily extensible through the use of user-defined tags and engine plug-ins to process them.

An Active Document is a document that contains literal elements which are not processed. Instead, these elements are passed through to the output document. This is the same as the way literal result elements are handled in an XSLT stylesheet. An Active Document can thus act as a template for a class of dynamically created documents. For example, an Active Document might be a template for a Web page -- it would contain literal XHTML elements and Active Tags elements that instructed RefleX how to construct the rest of the document.

RefleX includes a set of tags for connecting to relational databases and executing SELECT and UPDATE statements. By embedding these tags in an Active Document, it is possible to retrieve relational data and create an XML document from that data. The results of a SELECT statement are returned using a table-based mapping. The results can then be addressed with XPath and placed anywhere in the output document. For example, a result value could be used as the content of a literal element or attribute, or as a parameter in a child SELECT statement.
sql2dtd, dtd2sql, xml2sql

Developer: David Mertz
URL: http://gnosis.cx/download/Gnosis_Utils-current.tar.gz,
http://www.ibm.com/developerworks/xml/library/x-matters9.html
http://gnosis.cx/publish/programming /xml_matters_12.txt
License: Public domain
Database type: Relational
Direction(s): Database => XML, XML => Database
Entry last updated: November, 2008

sql2dtd is a Python module that generates a DTD from a SELECT statement using a table model. This is designed to be used with Scott Hathaway's sql2xml.

dtd2sql is a Python module that generates a set of SQL CREATE TABLE statements from a DTD using an object-relational mapping. xml2sql is a Python module that generates a set of SQL INSERT statements from an XML document, again using an object-relational mapping. The user must execute the SQL statements to create the tables and insert the data.
sql2xml

Developer: Scott Hathaway
URL: http://www.hcsprogramming.com/dow nloads/scripts/sql2xml.py,
http://www.ibm.com/developerworks/xml/library/x-matters9.html
License: Public domain
Database type: Relational (mxODBC)
Direction(s): Database=>XML
Entry last updated: July, 2001

A Python module that generates an XML document from a SELECT statement using a table model. Uses mxODBC for database access.
SQL2XML.SQL

Developer: Rob Verschoor/Sypron B.V.
URL: http://www.sypron.nl/sql2xml.sql
License: Open Source / Non-commercial only
Database type: Relational (Sybase only)
Direction(s): Database=>XML
Entry last updated: December, 2008

SQL2XML.SQL is a set of stored procedures that can be used only on Sybase. They return the rows in a table or view as XML using a table-based mapping. One element is returned for each row and child elements are returned for each column. The row elements use the table name and the column elements use column names. The root element is named "resultset". Options include using different names for the column elements, restricting the columns to be returned, and providing WHERE and ORDER BY clauses to restrict and sort the data to be returned.
sqlToXml, xmlToSql

Developer: Jim Kent
URL: http://hgwdev.cse.ucsc.edu/~kent/src/ddj KentXml.zip
License: Free for non-commercial use
Database type: Relational
Direction(s): Database=>XML, XML=>Database
Entry last updated: December, 2006

sqlToXml is a command-line utility for creating an XML document from data in a MySQL database. (The code can be modified to work with other databases.) It uses an object-relational mapping, where data is stored in attributes in the XML document. The mapping is specified with a simple, text- based mapping language where indentation indicates parent-child relationships. Users must specify the name of the tables to be mapped, as well as the names of the primary and foreign key columns used to link tables. Users can also specify the name of the root element and whether to ignore certain columns. sqlToXml can also accept a SELECT statement instead of mapping information.

xmlToSql is a command-line utility for storing the data in an XML document in a relational database. The structure of the document must match the structure of the tables in the database. As input, it accepts an XML document, a DTD, and a statistics file. The DTD and statistics file are produced by the autoDTD utility, which creates them from the instance document. The statistics file contains information that xmlToSql uses to decide which fields to index. The output of xmlToSql is a directory of tab-separated files and SQL statements that can be used to load data into any relational database. xmlToSql also attempts to identify integer fields that can be used as primary / foreign keys.

sqlToXml and xmlToSql also ship with autoXml, an XML data binding utility.
SQLXML

Developer: Microsoft
URL: http://msdn.microsoft.com/en-us/library/aa286527.aspx
License: Commercial
Database type: Relational (SQL Server only)
Direction(s): Database=>XML, XML=>Database
Entry last updated: December, 2008

SQLXML is a client-side utility (ADO or .NET) that transfers data between XML documents and Microsoft SQL Server. (It should not be confused with SQL/XML, which are the ISO extensions to SQL for XML.) SQLXML uses an object-relational mapping to map the XML schema to the database schema. This is specified by annotations in an XML Schema document. (XML-Data Reduced (XDR) schemas are also supported, but these are outdated.)

To transfer data from the database to XML, applications can provide a mapping schema, or a mapping schema and an XPath query. If only a mapping schema is provided, SQLXML returns all of the data identified by the mapping schema. For example, if the mapping schema maps three columns of a table to an XML schema, then all of the data in those columns will be returned. To restrict the amount of data that is returned, a mapping schema can contain annotations that limit the data by column and value; such annotations function as a simple WHERE clause. If the application provides both a mapping schema and an XPath query, then SQLXML returns the data specified by the XPath query. The query is executed against the virtual XML document defined by the mapping schema. In both cases, the application can also specify an XSLT stylesheet to be run against the XML document returned by SQLXML.

To transfer data from an XML document to the database, the application can either use the XML bulk load tool or an "updategram". The XML bulk load tool accepts an XML document and a mapping schema, and transfers data from the XML document to the tables and columns specified in the mapping schema. An updategram is a specially formatted XML document that contains the new data -- "before" and "after" data for updates, "after" data for inserts, and "before" data for deletes. If an updategram is provided without a mapping schema, then SQLXML uses the element and attribute names in the updategram as table and column names. If an updategram is provided with a mapping schema, then SQLXML uses the mapping schema to map element and attribute names to table and column names.
SXQL

Developer: Goetz Hatop
URL: http://www.hatop.de/sxql.html
License: Shareware
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2000

Java classes for transferring data between a JDBC database and an XML document. The product uses templates. When transferring data from the database to XML, the templates contain embedded SELECT statements. The results from these statements can be placed elsewhere in the template, including other SELECT statements. This allows deeply nested documents to be created.

When transferring data from XML to the database, the templates are XSLT stylesheets. These exploit the ability of the Apache Xalan XSLT processor to support extensions. In particular, XSLT commands are used to turn data into XSLT variables, which are then used in INSERT statements executed by SXQL. The use of XSLT variables allows deeply nested XML documents to be inserted into the database.
X:Forge

Developer: Bibop Research International
URL: http://xforge.sourceforge.net/
License: Open Source
Database type: Relational (JDBC), native XML databases (XML:DB)
Direction(s): Database=>XML
Entry last updated: November, 2008

X:Forge generates XML documents based on templates. The template language is very simple and consists of literal elements and elements that result in calls to external Java components, which return XML in the form of SAX events. Some components are shipped with the system, but users can also write their own, making the system arbitrarily extensible.

X:Forge comes with two database components. The first transforms the result of a SELECT statement into SAX events using a table-based mapping. The second is a thin wrapper over the XML:DB API and can be used to retrieve an XML document from any XML:DB-enabled database. X:Forge also includes a component for performing XSLT transformations.
xlinkit

Developer: xlinkit.com
URL: http://www.systemwire.com/produ cts/xlinkit/engine/index.html
License: Commercial
Database type: Relational (JDBC)
Direction(s): Database=>XML
Entry last updated: February, 2002

With xlinkit, the user specifies a set of XML documents and a set of rules. The rules specify a set of conditions that are to be checked against the documents. For example, does a product name in one XML document match a product name in another XML document? The result of checking these rules is a linkbase -- a document containing XLinks that point to the targets of the rules and states whether the rules succeeded or failed.

As an integration tool (as opposed to validation tool), the interesting part of the result is the linkbase. This can be passed to an XLink processor or transformed with XSLT to create an XML document containing the checked data. xlinkit comes with two tools for processing linkbases. XTooX takes a linkbase and places those links directly into the relevant documents. Pulitzer is a report generator that allows you to generate XML pages (such as XHTML) from the linkbase.

The XML documents in the document set may come from any source and the mechanism that fetches them is arbitrarily extensible. In particular, users specify the name of a class that implements the DocumentFetcher interface and the address of a document to be retrieved by this class. xlinkit instantiates the class and asks it to retrieve the specified document.

In the case of database data, xlinkit includes a simple implementation of DocumentFetcher that returns the result of a SELECT statement as XML using a table-based mapping.
XML Converter

Developer: RustemSoft
URL: http://www.rustemsoft.com/xmlconverter1.asp
License: Commercial
Database type: Relational (ODBC)
Direction(s): Database=>XML
Entry last updated: November, 2008

XML Converter is software for transferring data from a relational database, Excel spreadsheet, CSV or tab-delimited file, or Word document to an XML document. It apparently uses a table-based mapping and also apparently allows users to choose element type and attribute names. Data can be output as a plain XML document, an XML document with an inline XML Schema describing the relational structure, an XML document with an inline DTD, or an XML document that uses the Oracle TransX schema. XML Converter can also generate an XSLT stylesheet, apparently based on user input.

XML Converter comes with a GUI tool for mapping data from the database to XML. It has a Standard Edition that allows users to create XML documents only by using the GUI tool and Professional/Corporate Editions that allow users to create XML documents via a command-line interface. The latter allows XML Converter to be called from applications.
XML-DBMS

Developer: Ronald Bourret, Nick Semenov, Adam Flinton, and others
URL: http://www.rpbourret.com/xmldbms/index.htm
License: Open Source
Database type: Relational (JDBC, DBI)
Direction(s): Database=>XML, XML=>Database
Entry last updated: January, 2003

XML-DBMS is middleware for transferring data between an XML document and a relational database. It uses an object-relational mapping that is described by an XML-based mapping language. Mappings can be written by hand or automatically generated from a DTD or database schema. In addition, both DTDs and database schemas can be generated from a mapping, allowing generation of database schemas from DTDs and vice versa.

Like most object-relational mapping languages, the language in XML-DBMS maps complex element types to tables, maps simple element types, attributes, and PCDATA to columns, and maps nesting to joins. Additional features include simple transformations (flattening of structure found in the XML document but not the database), distributing the data from a single document across multiple databases, custom string formatting and parsing routines, generation of keys by the database and user-defined routines, support for list-valued attributes and element types, and support for maintaining the order of child elements in their parent.

When transferring data from an XML document to the database, users can specify what actions to take. That is, whether to insert, update, or insert-or-update the data. Actions are specified on a per-complex element type basis. When transferring data from the database to an XML document, users can use filters (WHERE clauses) to specify which data is to be retrieved. These can be parameterized for greater flexibility. Data can also be deleted from the database according to a particular filter and map. Other features include support for per-statement, per-document, and application-defined transaction boundaries, XML parser independence, and optional validation.

Applications can use XML-DBMS through either of two interfaces. The first interface is property based. That is, users pass in properties for the XML document to/from which to transfer data, the map, filter, and/or action documents, and various configuration parameters. This can be done from the command line or a program. The second interface provides greater control and allows applications to address lower-level classes directly, transferring data to/from a DOM tree. An additional properties-driven tool is available for use at design time to generate maps.

XML-DBMS version 1.x is available in both Java and PERL. Version 2.0 is available only in Java. XML-DBMS comes with JavaDocs, a user's guide, and sample code.
xmlDig

Developer: SysOnyx
URL: http://www.sysonyx.com/Products/xmlDig/inde x.asp
License: Commercial
Database type: Relational (OLE/DB)
Direction(s): Database=>XML
Entry last updated: November, 2008

xmlDig is middleware for transferring data from a relational database to an XML document. XML documents are designed by building a set of nested SELECT statements. The results from one statement can be used to parameterize child statements so that parent-child relationships can be built. xmlDig comes with a GUI tool for designing and creating documents and is based on Microsoft ADO.
XML::Generator::DBI

Developer: Matt Sergeant
URL: http://search.cpan.org/~msergeant/XML-Generator-DBI-1.00/DBI.pm
License: Open Source
Database type: Relational (DBI)
Direction(s): Database=>XML
Entry last updated: January, 2002

A PERL module for transferring data from DBI databases to XML. The product models the XML document as a table. Input to the module is a SELECT statement. Output is SAX events, which can then be written to a string, file, etc. This module replaces DBIx::XML_RDB.
XQuare Bridge, XQuare Fusion

Developer: Odonata
URL: http://xquare.objectweb.org/bridge/index.html,
http://xquare.objectweb.org/fusion/index.html
License: Open Source
Database type: Relational (JDBC), XML documents
Direction(s) : Database=>XML (both), XML=>Database (XQuare Bridge only)
Entry last updated: March, 2004

XQuare Bridge (formerly E-XMLMedia XMLizer, then XQuark) is middleware for transferring data between XML documents and relational databases. It uses XQuery to transfer data from the database to XML and a proprietary mapping language to transfer data from XML to the database.

The XQuery implementation is known as the Extractor. By default, it maps each table to a collection of XML documents and each row to a single XML document. It uses a table-based mapping, with columns represented as child elements. Users can customize the mapping, including or excluding tables and/or columns by name or according to a regular expression. Users can then use XQuery to query the virtual documents defined by a particular mapping. Although the virtual documents are flat, deeply nested XML documents (such as those that include data from multiple tables) can be constructed by using nested XQuery queries. XQuare Bridge translates XQuery queries into SQL statements, which are executed on the underlying database.

The Mapper is the part of XQuare Bridge that inserts data into the database. It uses an object- relational mapping that is specified with a proprietary, XML-based mapping language. The language includes support for defining how primary keys are obtained (from the XML document, from a user- defined function, or from system variables), flattening the XML structure, checking whether rows exist before inserting them, and updating rows (as opposed to inserting them).

XQuare Fusion is a heterogeneous join engine that supports XQuery. Currently, it can query data from XML documents and from relational databases wrapped by the XQuare Bridge.

Applications call both the XQuare Bridge and XQuare Fusion through the Java-based XML/DBC API. The API includes methods for operations such as connecting to the database, submitting queries (inserts and XQuery queries), and fetching results as DOM 2.0 documents, SAX 2.0 events, or a string.