Ronald Bourret

Consulting, writing, and research in XML and databases

XML Database Products:

Middleware

Overview

Middleware is software used by data-centric applications to transfer data between XML documents and databases. It is usually lightweight, and usually runs in the same process space as the application. Most of it accesses data in relational databases using ODBC, JDBC, or OLE DB, although some products exist for other types of databases, such as multi-valued databases. Middleware products range from home-grown projects to multi-thousand-dollar data conversion engines.

Related categories

• IDEs and Editors: Software you use to write XML applications or edit XML documents.
• XML-Enabled Databases: Databases with extensions for transferring data between XML documents and themselves.
• XML Servers: XML-aware J2EE servers, Web application servers, integration engines, and custom servers.

Products

ADO

Developer: Microsoft
URL: http://msdn2.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.

Alliance XML/400

Developer: Patrick Townsend & Associates
URL: http://www.patownsend.com/XML.htm
License: Commercial
Database type: Relational (AS/400)
Direction(s): Database=>XML, XML=>Database
Entry last updated: August, 2003

From the Web site:

"Alliance XML/400 is a AS/400 data translation application that converts data from XML format to AS/400 database format, and from AS/400 database format to XML. AS/400 developers and analysts can use Alliance XML/400 to create applications that perform real-time or batch translation of XML data. No programming is required to create XML inbound and outbound translation maps. Translation tasks can be automated using the Alliance Library Scan facility or you can use the Alliance Application Program Interfaces (APIs) to perform translation tasks. Alliance XML/400 provides translation history, application logging, and sample code. Alliance XML/400 includes Web HTTP and HTTPS communications, and SMTP and POP email clients. Additional communication options are available."

Allora

Developer: HiT Software
URL: http://www.hitsw.com/products_services/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_mapforce.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.

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 theOpenXML 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.

C24 Integration Objects

Developer: Century 24 Solutions
URL: http://www.c24.biz/c24io_xml.htm
License: Commercial
Database type: Relational (JDBC/JDO)
Direction(s): Database=>XML, XML=>Database
Entry last updated: June, 2004

C24 Integration Objects for XML is an optional module for C24 Integration Objects that performs XML data binding and can be used to transfer data between XML documents and relational databases. C24 Integration Objects is a general data binding product that supports bindings to a variety of data formats, including relational databases, CSV files, and RTF.

C24 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 transfer data from an XML document to a relational database, the input presentation would be XML and the output presentation would be a relational database. Other combinations are possible as well. For example, to duplicate traditional XML data binding, both the input and output presentations would be XML. Or data could be 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.

C24 Integration Objects for XML can create a structure from a DTD, an XML 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.

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.

Charteris Integration Toolkit

Developer: Charteris plc
URL: http://www.charteris.com/capability/technology/XMLToolkit/Overview.asp
License: Commercial
Database type: Relational (ODBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: December, 2002

Charteris Integration Toolkit is a tool for transferring data between multiple systems, including relational databases. To use the toolkit, users:

1) Wrap all systems (except relational databases) in XML documents. That is, the data exposed by a particular system must be made available as an XML document. How this is done is up to the user; the toolkit does not provide any tools for this.

2) Define a "business object model" in UML (using XMI) or DAML.

3) Use a proprietary mapping language to map between the individual system schemas (as represented by XML or relational schemas) and the business object model. This language can handle relationships between objects, so an object-relational mapping between XML documents and relational databases is possible.

Once the mappings are in place, the toolkit can transfer data between any two nodes of the system -- XML <=> XML, XML <=> relational database, or relational database <=> relational database -- using XSLT to perform any necessary transformations. XML documents can be represented as text or DOM trees.

The toolkit comes with a number of tools, including a GUI-based mapping tool that supports XML Schemas, XML Data Reduced, and RELAX NG, a "comparative query tool" for querying the object model and seeing how the same data is stored on different systems, and a Java API for transferring data between a set of objects matching (and presumably generated from) the business object model and an XML document or relational database. The latter serves as both an object-relational engine and an XML data binding solution.

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.

Connect for SQL/XML (formerly jXTransformer)

Developer: DataDirect Technologies
URL: http://www.datadirect.com/products/sql_xml/index.ssp
License: Commercial
Database type: Relational (JDBC, SequeLink)
Direction(s): Database=>XML, XML => Database
Entry last updated: August, 2003

Connect for SQL/XML is a JDBC driver that implements the SQL/XML specification as well as JDBC. (SQL/XML is a standard set of extensions to SQL for constructing XML from relational data.) It has extensions for retrieving XML documents from result sets and for inserting, updating, and deleting data based on the values in an XML document.

When an application passes an SQL/XML query to Connect for SQL/XML, Connect for SQL/XML executes it -- retrieving data from the database as needed -- and returns the results in a normal JDBC ResultSet. XML values are returned in columns whose type is XML. Applications retrieve these XML values with the getObject method, which returns an XMLType object. The XMLType class is a proprietary extension to JDBC and can return XML values as a DOM or JDOM tree, SAX events, or text.

Connect for SQL/XML has extensions to the INSERT, UPDATE, and DELETE statements that allow applications to modify data in the database based on values in an XML document. These allow multiple tables to be modified with a single statement and use a table-based mapping. In particular, an application uses an XPath expression to designate a set of nodes that correspond to rows. That is, one row is inserted, updated, or deleted for each node in this node set. For INSERT statements, the application then uses relative XPath statements to specify the nodes that correspond to columns. For UPDATE statements, the application uses relative XPath statements to specify the nodes containing new values. For both UPDATE and DELETE statements, the application may use relative XPath statements to specify nodes whose values are used in the WHERE clause.

Connect for SQL/XML includes an GUI-based query builder and supports JAXP 1.1. It also supports the jXTransformer API and query syntax. (jXTransformer was an earlier version of Connect for SQL/XML and implemented an early version of SQL/XML.)

Internally, Connect for SQL/XML uses a DataDirect Connect for JDBC driver or a SequeLink Java Client to access the database. These allow it to access data in DB2, Informix, SQL Server, Oracle, Sybase, and Progress databases.

DataDirect XQuery

Developer: DataDirect Technologies
URL: http://www.datadirect.com/products/xquery/index.ssp
License: Commercial
Database type: Relational (JDBC), XML
Direction(s): Database=>XML
Entry last updated: September, 2006

DataDirect XQuery is a standalone Java XQuery engine that can query relational and XML 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 and pieces that query XML sources and flat files are passed to the XML adaptor. The adaptors 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 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 adaptors, which map data to XML. Adaptors are available for a number of flat file formats, including EDI (Edifact and X12), dBase, RTF, CSV, and HTML.

DataDirect XQuery implements an early version of XQuery API for Java (XQJ). It supports calls to Java methods and SQL functions (stored procedures) and provides a Java function for invoking Web services. It can be used via the Stylus Studio and oXygen IDEs.

Data Integrator

Developer: Pervasive Software(who bought Data Junction, Inc.)
URL: http://www.datadirect.com/products/sql_xml/index.ssp
License: Commercial
Database type: Relational (ODBC, OLE DB, Native Drivers), ISAM, etc.
Direction(s): Database=>XML, XML=>Database
Entry last updated: March, 2002

Data Integrator is a transformation engine that can convert between more than 100 database and non-database formats, including XML. XML Junction is the same as Data Junction, except that either the target or the source of the transformation must be XML. It can also generate XML schemas and DTDs and understand BizTalk XDR Schemas.

At the core of both products is a transformation engine, which uses a spoke and wheel architecture. That is, an adaptor converts data from a source (a spoke) to a common format (the wheel). A different adaptor is then used to convert the data to the target (another spoke). This allows new data formats to be easily plugged in by simply writing a new adaptor. The transformation engine may be run from the command line or from an application.

Both products include GUI-based tools for mapping from one format to another. These allow users to construct arbitrary mappings between source and target. Table-based and object-relational mappings are therefore possible, as are more complex mappings. (It is not clear what happens when the user constructs a mapping that is not reversible.) Functions can be applied to the data during transformation, allowing such things as data conversion, validation, and formatting. The tools recognize XML as well as other markup formats and can use XML Schemas for schema-driven mapping.

DB2XML

Developer: Volker Turau
URL: http://www.informatik.fh-wiesbaden.de/~turau/DB2XML/index.html
License: Open Source
Database type: Relational (JDBC)
Direction(s): Database=>XML
Entry last updated: November, 2000

Java classes for transferring data from a relational database to an XML document. These classes may be used in a standalone application or as a servlet. The product models the XML document as a set of tables, for which the user specifies one or more SELECT statements. Options include specifying the tag names to be used on output, as well as whether to include database metadata in the document. The document may be returned as a file, stream, or DOM object and support for passing it to an XSL processor is provided.

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::XMLMessage

Developer: Andrei Nossov
URL: http://cpan.uwinnipeg.ca/htdocs/DBIx-XMLMessage/DBIx/XMLMessage.html
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://cpan.uwinnipeg.ca/htdocs/DBIx-XML_RDB/DBIx/XML_RDB.html
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: DataMirror Corp.
URL: http://www.datamirror.com/products/dbxmltransform/default.aspx
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.

Easysoft XML-ODBC Server

Developer: Easysoft
URL: http://www.easysoft.com/products/2006/main.phtml
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.

e.Report

Developer: Actuate
URL: http://www.actuate.com/products/server/index.asp
License: Commercial
Database type: Relational
Direction(s): Database=>XML
Entry last updated: October, 2001

e.Report is an XML-enabled report writer. It can extract data from a variety of sources, including XML documents and relational databases, and generate reports in a variety of formats, including HTML, PDF, and XML.

Users design reports with a GUI-based tool. To create an XML document, they specify whether each field in the report is to appear as an element or an attribute and what element/attribute name to use. Nesting in the XML document follows nesting in the report. The mapping from databases to reports is not specified. However, based on screen shots, it appears that it uses templates, where the user designs the template with the GUI tool.

e.Report also uses XML as its "internal exchange format", which uses a proprietary DTD. Developers can access reports in this format, which they can then transform or manipulate as they like.

e.Report comes in both a server version and an embedded version. The server version can be used to deliver XML documents via HTTP. The embedded version can be embedded in any J2EE application.

eTools XML

Developer: GA eXpress
URL: http://www.gaexpress.com/epath/etools/xml/
License: Commercial
Database type: MultiValue (mv.BASE, mvENTERPRISE, UniVerse (Ardent), Unidata (Ardent))
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2001

From the Web site:

"eTools XML is a set of components and API extensions that are specifically geared to accessing MultiValue data, and manipulating and integrating it into XML. Using standard programming environments like Visual Basic and Java Script, ... developers can create custom applications that convert MultiValue data into XML format and back ..."

Extreme Translator

Developer: Etasoft
URL: http://www.xtranslator.com/
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, etc.) and relational databases. 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.

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.

iConnector

Developer: infoteria
URL: http://www.infoteria.com/products/product_page.jsp?id=/product/product_3.xml
License: Commercial
Database type: Relational (ODBC), Lotus Notes/Domino
Direction(s): Database=>XML, XML=>Database
Entry last updated: November, 2000

Middleware for transferring data between XML documents and various databases. The product the XML document as a single table. A GUI tool is included for mapping between the XML document and the database and the mapping is apparently stored as an XSLT document. Although iConnector uses ODBC, its use is restricted to drivers tested by the company. iConnector can be run from Java, as a COM object, or as a Windows service.

idx-xmnesia

Developer: IDEALX
URL: http://www.idealx.org/prj/idx-xmnesia/
License: Open Source
Database type: mnesia
Direction(s): Database=>XML, XML=>Database
Entry last updated: Summer, 2001

From the Web site:

"idx-xmnesia is an Erlang library providing the functionnality to store XML data into a mnesia database. It can be directly used from within the Erlang Virtual Machine or accessed from various other languages, such as Python."

iWay XML Transformation Engine (iXTE) (formerly XML Transformation Server, eBix)

Developer: iWay Software (a subsidiary of Information Builders)
URL: http://www.iwaysoftware.com/iWay_ebix.html
License: Commercial
Database type: Relational (ODBC, OLE DB, JDBC, native drivers), hierarchical, SAP, PeopleSoft, etc.
Direction(s): Database=>XML, XML=>Database
Entry last updated: February, 2002

iWay XML Transformation Engine (iXTE) is a Java-based transformation engine that uses iWay Adapters to convert between more than 140 database and non-database formats, including XML. Transformations are defined in a GUI-based editor and can use XSLT. Custom, user-written transformations can be used as well. The possible mappings between XML and databases are not known.

iXTE apparently functions as a standalone server and includes server capabilities such as clustering, load management, and document queues. It includes a SOAP interface and can be accessed from a number of programming languages.

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://www.mysql.com/doc/en/mysql.html
License: Open Source
Database type: Relational (MySQL)
Direction(s): Database=>XML
Entry last updated: March, 2004

mysql is a command line utility for executing queries against a MySQL database. mysqldump is a command line utility for dumping data from MySQL databases. Both have an option for using XML as their output format. Presumably, this uses a table-based mapping. mysql allows users to execute any SQL query. mysqldump allows users to specify which tables to dump and to specify a where clause to restrict the rows that are dumped. 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.

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.

PowerXML Pro

Developer: Wizen Software
URL: http://www.wizen.com/content/pro.htm
License: Commercial
Database type: Relational (ODBC)
Direction(s): Database=>XML, XML => Database(?)
Entry last updated: February, 2002

PowerXML Pro is a "tool for building data integration pipelines." Pipelines follow a "simple three-step visual pipeline metaphor (Input, Process, Output)" and allow data to be "extracted, combined, filtered, and transformed between a variety of data sources including: files, applications, databases, web-sites, mainframes, and web-services." Database access is via ODBC and appears to use a table-based mapping.

PowerXML Pro includes an implementation of XPath and support for multiple XSLT engines. It can use data from more than 100 file formats, as well as a variety of application formats (SAP, Excel, etc.), and comes with "numerous built-in actions to combine, filter, remove, process, and transform XML data."

PowerXML Pro has COM, Java, HTTP, and SOAP interfaces.

sql2dtd

Developer: David Mertz
URL: http://gnosis.cx/download/Gnosis_Utils-current.tar.gz,
http://www-106.ibm.com/developerworks/xml/library/x-matters9.html?open&l=136,t=grx,p=xmat9
License: Public domain
Database type: Relational
Direction(s): Database => XML
Entry last updated: July, 2001

A Python module that generates a DTD from a SELECT statement using a table model.

sql2xml

Developer: Scott Hathaway
URL: http://www.hcsprogramming.com/downloads/scripts/sql2xml.py,
http://www-106.ibm.com/developerworks/xml/library/x-matters9.html?open&l=136,t=grx,p=xmat9
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.

sqlToXml, xmlToSql

Developer: Jim Kent
URL: http://hgwdev.cse.ucsc.edu/~kent/src/ddjKentXml.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.

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.

Sypram XML Studio

Developer: Sypram Technology
URL: http://www.sypram.com/ProServices.htm
License: Commercial
Database type: Relational (OLE-DB)
Direction(s): Database=>XML
Entry last updated: February, 2002

Sypram XML Studio is a set of COM+ components designed to be used by ASP and optimized for MTS. The XMLDB component is used to access data in relational databases. XMLDB uses a table-based mapping, with column data returned as child elements.

SysDB

Developer: Sysalys
URL: http://www.sysalys.com/com/products.php, http://www.sysalys.com/com/doc/
License: Shareware
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: March, 2004

SysDB is a GUI-driven tool for transferring data between XML documents and a relational database. Unlike almost all similar products, SysDB tracks the XML documents whose data it has stored. In this sense, it functions as a document store, allowing users to store, retrieve, and explore XML documents using a relational database.

SysDB uses an object-relational mapping that is described by an XML-based mapping language. It generates mappings and database structures automatically from XML Schema documents and can update both mappings and database structures when an XML Schema document changes.

When storing XML in the database, users can treat an XML document as a new document or an updated document. For new documents, SysDB inserts all the data from the document into the database and tracks that data as a new document. For updated documents, SysDB only modifies the data that has changed. It tracks the changes to the data, allowing any version of the document to be retrieved.

When retrieving XML from the database, users can retrieve entire documents or extract fragments of documents. When retrieving entire documents, they can retrieve any version of the document. When extracting fragments of documents, the user first searches for the data they want, then extracts it as XML. Two search styles are supported. The first is a hierarchical search, where the user searches along the document hierarchy. The second is a value search, where the user specifies a regular expression for a one or more elements or attributes. In both cases, the system displays the corresponding data and then allows the user to narrow the search.

SysDB is based on XML-DBMS (version 1.x) and uses the mapping language from that product. However, the XML-DBMS code itself has been heavily modified.

truExchange XML

Developer: nuBridges
URL: http://www.nubridges.com/solutions/xml.htm
License: Commercial
Database type: Relational (AS/400)
Direction(s) : Database=>XML, XML=>Database
Entry last updated: August, 2003

truExchange XML consists of both client and server software. It can transfer data from XML documents to AS/400 data structures and vice versa. Supported data structures include DB2 files, IFS files, data queries, and program data structures.

Data is transferred according to a particular mapping, which the user specifies with a GUI-based mapping tool. Exactly what mappings are possible is not known. During data transfer, some transformations are possible, including conversion to/from a number of date formats, concatenating strings, and extracting substrings.

truExchange XML can be called through SMTP, HTTP, EDI-INT, FTP and Sockets.

XChainJ

Developer: Cogent Logic Corp.
URL: http://xchainj.com/
License: Commercial
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database
Entry last updated: February, 2002

XChainJ is an XML data binding product. It includes methods to transfer data from XML documents to Java objects to the database and vice versa. It comes with a GUI-based mapping tool that can be used to map between DTDs, Java classes, and database schema.

X:Forge

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

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.

xlinkit

Developer: xlinkit.com
URL: http://www.systemwire.com/products/xlinkit/engine/index.html
License: Free for non-commercial use, otherwise 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 DataDesk

Developer: NetBryx Technologies
URL: http://www.netbryx.com/DataDesk.aspx
License: Commercial
Database type: Relational (ODBC, OLE DB)
Direction(s): Database=>XML
Entry last updated: July, 2002

XML DataDesk is middleware for transferring data from a relational database to an XML document stored as a file on the file system. Users define a mapping with a GUI-based tool by (a) selecting columns from one or more tables, (b) entering a SELECT statement, or (c) entering the name of a file containing a SELECT statement. The tool formats the results using a table-based mapping, with column values returned as child elements. (When more than one table is chosen, results are listed sequentially.)

Once the basic mapping is defined, users can specify a limited number of transformations, such as renaming, inserting, or removing elements. The transformations are stored in an XSLT stylesheet for later use.

After defining the mapping and any transformations, users transfer data by calling XML DataDesk from the command line or through the GUI-based tool.

XML DataDesk is currently in beta [July, 2002].

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.

XML for Tables (formerly Experanto, XTables)

Developer: IBM
URL: http://www.alphaworks.ibm.com/tech/xtable
License: Evaluation only
Database type: Relational (DB2)
Direction(s): Database=>XML
Entry last updated: April, 2003

XML for Tables implements a subset of XQuery over DB2. It is written in Java and is available to applications through a set of DB2 stored procedures.

XML for Tables models each table as a single XML document, using the naming rules from SQL/XML. Users can then query these virtual XML documents using XQuery. This allows the construction of arbitrary XML documents from relational data. (Note that data from two or more tables can be joined within the XQuery statement itself.) XML for Tables translates XQuery statements into SELECT statements, translating the results of these statements into XML.

In addition, users can construct "XML views" of relational data. Just as SQL views define virtual (unmaterialized) tables, XML views define virtual (unmaterialized) XML documents. And just as SQL views can be queried with SELECT statements, XML views can be queried with XQuery statements. XML views are defined using XQuery statements, and the composability of XQuery statements means that queries against XML views can be optimized by composing the XQuery statements that define and query the view.

XML Gateway

Developer: SPI Ltd.
URL: http://www.xmlgateway.co.uk/
License: Commercial
Database type: Relational (OLE DB, ODBC), Excel, Word, text files
Direction(s): Database=>XML, XML=>Database
Entry last updated: March, 2004

XML Gateway is middleware that transfers data between XML documents and relational databases (using OLE DB or ODBC), Excel spreadsheets, Word documents, or text files (CSV, tab-delimited, etc.). XML documents can reside on the file system, a Web site (from XML only), FTP site, message queue, Web service, or email (to XML only).

XML Gateway supports two primary operations: importing and exporting XML. "Importing" means to import data to XML and "export" means to export data from XML. This is the opposite sense from most products on this list, where "importing" refers to importing data from XML to the database and "exporting" means to export data from the database to XML.

When importing data to XML, data from multiple sources can be used to create a single XML document. The document can have a hierarchical structure. When exporting data from XML to an external source (such as a database or text file), data from a single XML document can be exported to multiple targets. This can be performed in a single transaction -- if there are multiple targets, this is a distributed transaction -- or in per-record transactions. In addition, the user can specify whether to insert, update, or delete data. Data transfer operations can be saved in an import or export module. This is a configuration file that includes information about the data source and target, mappings between source and target (if any), transaction mode, and so on.

XML Gateway can be used programmatically as a COM object. It can also be scheduled to run at regular intervals or used through a number of GUI tools. The latter include an XML editor and a Database Explorer, which includes a query designer. XML Gateway supports both DTDs and XML Schemas and can generate the latter. It appears to support XSLT, although this is not explicitly stated.

XML::Generator::DBI

Developer: Matt Sergeant
URL: http://aspn.activestate.com/ASPN/CodeDoc/XML-Generator-DBI/DBI.html
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.

XML Junction

See Data Junction Universal Translation Suite, XML Junction

XML Lightweight Extractor (XLE)

Developer: IBM
URL: http://www.alphaworks.ibm.com/tech/xle
License: Evaluation
Database type: Relational (JDBC)
Direction(s): Database=>XML
Entry last updated: November, 2000

XLE is a set of Java classes for extracting data from a relational database. It uses annotated DTDs as templates. For each scalar-valued construct (PCDATA-only element or attribute), the user can specify the table and column from which the value comes. The applicable row is determined by annotations that map element types with element content to tables. This makes it specify an object-relational mapping from the XML document to the database, but allows more complex mappings as well. Optional input parameters determine which data to actually retrieve. XLE comes with a GUI editor for annotating DTDs.

XMLServer

Developer: Hydrosoft
URL: http://www.hydrosoft.com.br/XMLServerEngine/IndexXMLServer.html
License: Free (not Open Source)
Database type: Relational (JDBC)
Direction(s): Database=>XML
Entry last updated: December, 2005

XMLServer is middleware for transferring data from a relational database to a set of XML documents. It uses an object-relational mapping, which the user specifies through annotations in an XML Schema document. The annotation language can only transfer data from columns to child elements (not attributes), but the language can handle one-to-one, one-to-many, many-to-one, and many-to-many relationships.

In the XML Schema, the user specifies a root table from which to start retrieving data. XMLServer constructs one XML document per row of data in this table. (Depending on the relationships between tables in the database, the document may contain multiple rows of data from subordinate tables.) Applications can retrieve the XML document corresponding to a particular key value in the root table, or the XML documents corresponding to all of the rows in the root table. In the latter case, the application retrieves one document at a time.

Internally, XMLServer uses both Java and the Mathematica kernel. It exists as a package in either language and can be called from either language without knowledge of the other language. It comes with a simple GUI, which can be used to retrieve data and display it as XML.

XQuare Bridge, XQuare Fusion (formerly E-XMLMedia XMLizer, then XQuark)

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 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.

XVRL (eXtensible Value Resolution Language)

Developer: xvrl.org
URL: http://www.xvrl.org/
License: Open Source
Database type: Relational (JDBC)
Direction(s) : Database=>XML
Entry last updated: Summer, 2001

XVRL is a template language that allows you to retrieve data from external sources, including relational databases. The language includes elements to declare a "resolver" class and call methods on it. The results of these method calls are returned to the processing software, which embeds them in the output document.

It appears that virtually any Java class can be used as a "resolver" class. Thus, the product is arbitrarily extensible. The software comes with an SQLDatabaseResolver class, which can return the results of a SELECT statement as XML using a table-based mapping.

There are two ways to process an XVRL document. First, JResolver is a simple command line utility that accepts an XVRL document and an optional XSLT stylesheet and returns the processed document. Second, JAVR (Java API for Value Resolution) allows you to process XVRL documents in your own application. JAVR conforms to Apache's Transformation API for XML (TrAX).