XML Database Products

Copyright 2000, 2001 by Ronald Bourret
Last full update: November 29, 2000
Last partial update: August 13, 2001

Table of Contents

1.0 Introduction
   1.1 XML and Databases
   1.2 Product Categories
   1.3 Terminology
   1.4 Disclaimer
   1.5 Copyrights, Trademarks, etc.
2.0 Products
   2.1 Middleware
   2.2 XML-Enabled Databases
   2.3 Native XML Databases
   2.4 XML Servers
   2.5 XML Application Servers
   2.6 Content Management Systems
   2.7 Persistent DOM Implementations
   2.8 XML Query Engines
3.0 Additional Links
4.0 Comments and Feedback

1.0 Introduction

The number of products for using XML with databases is growing with amazing speed -- new products seem to enter the market weekly. In this Web page, I have tried to capture the current state of the market, gathered from Web sites, product reviews, XML webzines, XML resource guides, and email from product users and developers.

1.1 XML and Databases

Although complete description of how to use XML with databases is beyond the scope of this page (see instead "XML and Databases"), a brief review will help you choose what product is right for you.

XML documents fall into two broad categories: data-centric and document-centric. Data-centric documents are those where XML is used as a data transport. They include sales orders, patient records, and scientific data. Their physical structure -- the order of sibling elements, whether data is stored in attributes or PCDATA-only elements, whether entities are used -- is often unimportant. A special case of data-centric documents is dynamic Web pages, such as online catalogs and address lists, which are constructed from known, regular sets of data. Document-centric documents are those in which XML is used for its SGML-like capabilities, such as in user's manuals, static Web pages, and marketing brochures. They are characterized by irregular structure and mixed content and their physical structure is important.

To store and retrieve the data in data-centric documents, you will need a database that is tuned for data storage, such as a relational or object-oriented database, and some sort of data transfer software. This may be built in to the database or might be third-party middleware. Depending on your needs, you may need Web publishing abilities as well.

To store and retrieve document-centric documents, you will need a native XML database or content management system. Both of these are designed to store content fragments, such as procedures, chapters, and glossary entries, and may include document metadata, such as author names, revision dates, and document numbers. Content management systems generally have additional functionality, such as editors, version control, and workflow control. Although content management systems generally use a native XML database for storage, this is hidden from the user.

1.2 Product Categories

I have divided products into the following categories. Please note that the boundaries between some of these categories, especially XML-Enabled Databases, Native XML Databases, XML Servers, and XML Application Servers, is somewhat arbitrary.

In general, you have to write code to integrate Middleware, XML-Enabled Databases, Native XML Databases, XML Servers, and Persistent DOM implementations with your applications. XML Application Servers require you to do some scripting, and Content Management Systems need to be configured, which may be a non-trivial task in itself.

1.3 Terminology

The terms template-driven and model-driven are described in section 5.2, "Mapping Document Structure to Database Structure" of "XML and Databases". The terms table-based mapping and object-relational mapping are described in "Mapping DTDs to Databases".

1.4 Disclaimer

DISCLAIMER: I last fully updated this list in November, 2000. I have undoubtedly missed some products and am not current on others. Because of this, be sure to check your favorite vendor's Web site for the latest information. Also, please note that I have not used any of these products except my own (XML-DBMS).

Although I have written most product descriptions based on documentation, Web sites, product reviews, and demos, some are quotes from Web sites or descriptions written specifically for this list by the companies that wrote the products. These are clearly labeled. Regardless of the source, you should consider the information in this document as an introduction only and research further on your own.

1.5 Copyrights, Trademarks, etc.

Quotes from Web sites and product descriptions written by companies are copyrighted by those companies. The remainder of this document is copyrighted by Ronald Bourret.

Unless you specifically know otherwise, it should be assumed that all product and company names are trademarked by their owners.

2.0 Products

2.1 Middleware

Middleware is software used by data-centric applications to transfer data between XML documents and databases. It is written in a variety of languages, but almost all of it uses ODBC, JDBC, or OLE DB. Although some of it can send data across the Internet, most of it needs to be used with a Web server if you need remote data access.

ADO

Developer: Microsoft
URL: http://msdn.microsoft.com/xml/articles/xmlintegrationinado.asp
License: Commercial
Database type: Relational (OLE DB, ODBC)
Direction(s): Database=>XML, XML=>Database

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 model-driven, using 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.

Allora

Developer: HiT Software
URL: http://www.hitsw.com/dsheets/alloramidware.htm
License: Commercial
Database type: Relational (ODBC, OLE DB, JDBC)
Direction(s): Database=>XML, XML=>Database

Allora is middleware that applications can call to retrieve data from a table, result set, or catalog query as a DOM Level 2 tree or as SAX 2 events. The XML document is modeled as a single table, with columns mapped to child elements.

Allora is available in Java and Windows versions. Both have essentially the same features -- they support DOM Level 2 and SAX 2 and can write the DOM tree out to a stream. The Java version has a few more options about how the DOM tree is constructed (element type names to use, column to designate as an ID attribute, whether to include a DTD, etc.). It can also track changes to the DOM tree and write these back to the database. The Windows version comes with a graphical database viewer and a tool for tracing Allora API calls.

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

A COM object for transferring data between an XML document and an ODBC or OLE DB data source. The product is model-driven and the XML document is modeled 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/content/products/detail.asp?catid=2&scatid=6&o=0
License: Commercial
Database type: Various, including relational and hierarchical
Direction(s): Database=>XML, XML=>Database

Not yet reviewed.

Beanstalk

Developer: Transparency
URL: http://www.transparency.com
License: Commercial
Database type: Relational (ODBC)
Direction(s): Database=>XML, XML=>Database

An object-relational engine that sits between the application and the database. The product extends the syntax of the SQL3 SELECT statement, allowing subselects in the select list to return a result set rather than just a scalar value. This allows the product to construct a tree of result sets that are nested arbitrarily deep. These can then be used, for example, to construct objects. A "patented technology" radically improves the speed with which data is retrieved by executing "one SQL selection per table." (I believe this means the number of queries depends only on the depth, and not on the width, of the hierarchy.)

To retrieve results as XML, the user includes an XML() function in the SELECT statement. This serializes the result sets with an object-relational mapping, where nesting in the result sets translates to nesting in the XML document. The user can specify whether to return results as elements or attributes, as well as the names of those elements and attributes. A similar syntax is used to insert data from an XML document into the database.

The product currently communicates with databases using ODBC; support for other types of communication is planned in the future. Applications communicate with the product using JDBC (1.x or 2.x).

Beanstalk will "soon be available" in beta release. [Ed. -- Written on 3 Oct, 00]

DatabaseDom

Developer: IBM
URL: http://www.alphaworks.ibm.com/tech/databasedom
License: Evaluation only
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database

A Java Bean for transferring data between a DOM tree and a single table in a database. The product is template-driven, with separate sections in the template for the database access information and the data layout. When transferring data from the database to the DOM tree, the user specifies a SELECT statement or a table name and WHERE clause; when transferring data from the DOM tree to the database, the user can only specify a single table name.

DataCraft

Developer: IBM
URL: http://www.alphaworks.ibm.com/tech/datacraft
License: Evaluation only
Database type: DB2, Microsoft Access
Direction(s): Database=>XML

A tool for generating SELECT statements and returning the results as an XML document containing a single table(?). From the Web site:

"... an application generation tool targeted for RDF/XML applications in the context of Web-commerce applications. DataCraft, a facility capable of generating visual query skeletons and running the queries against DB2, is an excellent tool for Web-Database application generation using XML. DataCraft provides client tools visually navigating resource schema, and query language building queries visually from the schema based on XML and RDF. DataCraft uses RDF and XML to describe data collection structures and to exchange resource schema and query between the server and client."

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

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 is model-driven and the XML document is modeled 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.

DBIx::XML_RDB

Developer: Matt Sergeant
URL: http://theory.uwinnipeg.ca/CPAN/data/DBIx-XML_RDB/XML_RDB.html
License: Open Source
Database type: Relational (DBI)
Direction(s): Database=>XML, XML=>Database

A PERL module for transferring data between XML and DBI databases. The product is model-driven and the XML document is modeled 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.

DB-X

Developer: Swift Inc.
URL: http://www.swiftinc.co.jp/en/frame/products/XMLServerWare/DB-X/
License: Commercial
Database type: Relational (ADO)
Direction(s): Database=>XML, XML=>Database

A Windows application (also available as an ISAPI extension) for transferring data from one or more ADO recordsets to an XML document. The product is template driven, using DB-X specific elements to embed queries in the template. Query results may be placed elsewhere in the document and the language is quite flexible, supporting embedded scripting language statements as well as programming constructs such as for loops and if statements. The Web page also states that updates are possible (which makes sense, given that the product is based on ADO), but does not show how to do this.

DB/XML Vision and xPower Transform

Developer: BDI Systems, Inc.
URL: http://www.bdisystems.com/dbxv.html,
http://www.bdisystems.com/xtrans.html
License: Commercial
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database (xPower Transform)

Middleware for transferring data from a relational database to an XML document. The products appear to be model-driven, using an object-relational mapping. (Note that the hierarchy is limited to ten levels deep for DB/XML Vision and three levels for xPower Transform.) Users can specify whether columns are mapped to elements or attributes and what names to use for each. xPower Transform can also use the data in an XML document to update the database; it does this based on customizable transformation rules. xPower Transform can also transform XML documents into flat files (such as comma-separated values files) and vice versa.

DB/XML Vision and xPower Transform can be run through a GUI, from a command line, or programmatically.

Delphi

Developer: Borland
URL: http://www.borland.com/delphi/del6/featurematrix/bizsnap.html
License: Commercial
Database type: Relational (Borland Database Engine, ADO, dbExpress, InterBaseExpress)
Direction(s): Database=>XML, XML=>Database

Delphi is an application development tool that supports the transfer of data between XML documents and databases through the use of client data sets. A client data set is one in which all of the data is local to the client. Client data sets can be bound to databases or XML documents. Thus, by binding one client data set to a database, binding another client data set to an XML document, and linking the data sets so that they operate on the same set of data, it is possible to transfer data between an XML document and a database. Furthermore, since data sets are updateable, updates made to the data set can be reflected in both the database and the XML document.

The mapping between a client data set and an XML document is table-based. However, since client data sets can contain other client data sets as column values, this effectively allows an object-relational mapping. Furthermore, because different mappings can be specified in either direction (XML to database and database to XML), the result is a slightly liberalized object-relational mapping.

iConnector

Developer: infoteria
URL: http://www.xmlsoft.com.au/iaccess.http://www.infoteria.com/en/contents/product/xml-s-c/index.htmlhtml
License: Commercial
Database type: Relational (ODBC), Lotus Notes/Domino
Direction(s): Database=>XML, XML=>Database

Middleware for transferring data between XML documents and various databases. The product is model driven, with the data modeled 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

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

Import Studio

Developer: Etasoft
URL: http://www.etasoft.com/impstd.htm
License: Commercial
Database type: Relational (ODBC)
Direction(s): XML=>Database

Not yet reviewed.

InterAccess

Developer: XML Software Corporation
URL: http://www.xmlsoft.com.au/iaccess.html
License: Commercial
Database type: Relational (ODBC, OLE DB)
Direction(s): Database=>XML, XML=>Database

A client/server package for accessing ODBC/OLE DB databases via the Internet, using XML over TCP/IP as a data transfer protocol. InterAccess Server runs on the server and processes requests, either retrieving data from the database and returning it to the client as XML, or receiving data in XML format from the client and storing it in the database. The format of the XML document is the same as that used by ADO, since ADO is used on the server for database access.

On the client side, a COM object handles communications with the server. Applications can either use a proprietary API on this object to access the data with an ADO-like programming model, or request that all XML responses from the server be directed to a callback function. The latter is useful when only the XML is needed and can be used to populate disconnected ADO Recordsets. InterAccess also has a proprietary browser, which acts as a front end for the COM object.

Of interest, InterAccess has built-in encryption and compression.

Net.Data

Developer: IBM
URL: http://www-4.ibm.com/software/data/net.data/
License: Commercial
Database type: Relational (ODBC, JDBC, Native Drivers)
Direction(s): Database=>XML

A Web server add-on for transferring data from a database to XML (or any text-based format). The product is template-driven, using a Net.Data-specific macro language. This is quite flexible, including variables, function definitions, loops, and if statements, as well as being able to parameterize SQL statements for nested queries.

ODBC2XML

Developer: Intelligent Systems Research
URL: http://members.xoom.com/gvaughan/odbc2xml.htm
License: Shareware
Database type: Relational (ODBC)
Direction(s): Database=>XML

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 is template-driven, 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://odbc.linuxave.net/
License: Open Source
Database type: Relational (ODBC, OLE DB)
Direction(s): Database=>XML

A server for accessing any ODBC or OLE DB database via the Internet, using XML over TCP/IP. The product is model-driven and the XML document is modeled 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.

PerXML Smart Transformation System

Developer: PerCurrence
URL: http://www.percurrence.com/products/index.html
License: Commercial
Database type: Relational
Direction(s): Database=>XML, XML=>Database

Not yet reviewed.

PXSLServlet

Developer: Paul A. Tchistopolskii
URL: http://www.pault.com/Pxsl/
License: Open Source
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database

A Java servlet for transferring data from XML documents to JDBC databases and vice versa. It can also delete data from the database. The product is template driven. When transferring data from the database to XML, parameters show where the results of SELECT statements are placed in the XML document. These can be used in additional queries, allowing nested queries to be constructed. The resulting XML document can then be transformed with XSL.

When transferring data from XML to the database (as well as when deleting data?), the template appears to act as a mapping from the XML document to the database. This is apparently done by parameterizing a sample XML document. At the least, it appears to create an object-relational mapping; more sophisticated mappings may be possible.

sql2dtd

Developer: David Mertz
URL: http://gnosis.cx/download/sql2dtd.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
Direction(s): Database => XML

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

sql2xml

Developer: Scott Hathaway
URL: http://members.home.net/slhath/downloads.html,
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

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

SXQL

Developer: Goetz Hatop
URL: http://www.hatop.de/
License: Shareware
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database

Java classes for transferring data between a JDBC database and an XML document. The product is template driven. 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://sypram.com/XML.htm,
http://sypram.com/XMLDB.htm
License: Commercial
Database type: Relational (OLE-DB)
Direction(s): Database=>XML

Not yet reviewed.

XML-DB Link

Developer: Rogue Wave Software
URL: http://www.roguewave.com/products/xml/xmldblink/
License: Commercial
Database type: Relational (OpenSQL -- a Rogue Wave database API)
Direction(s): Database=>XML, XML=>Database

A Web server plug-in that accesses databases based on predefined, parameterized SQL statements, called "services". Because the SQL statements are arbitrary, any SQL statement can be executed: SELECT, UPDATE, INSERT, DELETE, etc., even stored procedure calls. Of interest, parameters can accept arrays of values, allowing bulk inserts, updates, deletes, etc.

To execute an SQL statement, the client sends a request to the server in the form of a SOAP document. This contains the name of the service to be executed as well as any parameters needed by the service. XML-DB executes the service and returns any results to the client, again in the form of a SOAP document. In the case of SELECT statements, the results are formatted in XML as a set of tables.

XML-DB comes with visual tools for defining and testing services.

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

Java classes (also available as a PERL module) for transferring data between a relational database and an XML document. The classes may be used through a set of simple tools or accessed programmatically by user-written applications.

The product is model-driven, using an object-relational mapping that is described by an XML-based mapping language. Users can define how elements, attributes, and PCDATA are mapped to the database. The language is quite flexible and includes features such as the ability to store properties (attributes and PCDATA-only elements) in the class table or a separate property table, whether to store order information in the database, whether to generate key values (object IDs), and the format to use when parsing date, time, and timestamp values.

XML-DBMS can also generate relational schema (in the form of CREATE TABLE statements) from DTDs or DDML documents.

XML Junction and Data Junction Universal Translation Suite

Developer: Data Junction, Inc.
URL: http://www.xmljunction.net/, http://www.datajunction.com/products/index.html
License: Commercial (XML Junction is free as of Oct. 2000)
Database type: Relational (ODBC, OLE DB, Native Drivers)
Direction(s): Database=>XML, XML=>Database

Data Junction UTS is a transformation engine that can convert between many database and non-database formats, including XML. XML Junction contains a limited set of the features in Data Junction; it can also generate XML schemas and DTDs.

At the core of both products is a transformation engine, which includes drivers for each format and may be run from the command line or from an application. Also included are visual tools for mapping from one format to another; these recognize XML as well as other markup formats, as well as using XML Schemas for schema-driven mapping. How XML documents are modeled is unclear, although it appears they are modeled as a table or set of tables.

XML Lightweight Extractor (XLE)

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

XLE is a set of Java classes for extracting data from a relational database. It is template-driven, with an annotated DTD used as the template. 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.

XML Servlet

Developer: Cerium Component Software Incorporated
URL: http://ceriumworks.com/tech.html
License: Commercial
Database type: Relational (JDBC)
Direction(s): Database=>XML, XML=>Database

From the Web site:

"XMLServlet is a Java Servlet that uses XML instructions to combine XML or HTML templates with one another and with live database values. Use XMLServlet to display or update your database. Just give XMLServlet your fill-in-the-blank XML instructions. XMLServlet reuses the HTML (or XML) and SQL you use today."

It appears that for transferring data between XML documents and the database, XMLServlet models the document as a single table.

XML Servlet comes with two other tools: XMLOutline and XMLDB. XMLOutline takes a hierarchical outline, such as you might create in a text editor, and generates the corresponding DTD and an (empty?) XML document. XMLDB takes the DTD and XML document and generates the SQL statements needed to create the tables in which to store the document, including the necessary primary/foreign key relations.

XMLShark

Developer: infoShark
URL: http://www.infoshark.com/products/index.shtml
License: Commercial
Database type: Oracle
Direction(s): Database=>XML, XML=>Database

XMLShark transfers data between an Oracle database and an XML document that conforms to a proprietary schema. It is designed as a tool to regularly transfer data between two databases using XML as a data transport. Using a GUI, the user controlling the source database specifies what data to transfer, the server to transfer it to, and when to transfer it. Similarly, the user controlling the target database specifies when to read data from the XML document. Note that any application can intercept the generated document, since it is simply stored in the file system on the target server.

The XML document has three sections. The first section contains the metadata needed to model a database: tables, columns, data types, primary and foreign key constraints, and so on. The second part contains existing data, modeled as a set of tables. The third part contains data to be inserted, updated, or deleted, again modeled as a set of tables. Each part is optional.

If the XML document contains data that comes from a join, the data is not nested as might be expected. Instead, the data from each table is stored separately (hence the set-of-tables model). The advantage of this is that it provides an efficient format for transferring data, since the code to transfer non-nested data is generally faster than the code to transfer nested data. The disadvantage is that, because the data is not nested, the resulting document cannot be used by general-purpose XML applications.

XML SQL Utility for Java and XSQL Servlet

Developer: Oracle
URL: http://technet.oracle.com/tech/xml/
License: Development-only
Database type: Relational (JDBC)
Direction(s) : Database=>XML (both), XML=>Database (SQL Utility only)

XML SQL Utility for Java 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. The product is model-driven. If the database supports SQL 3 object views, it 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 or DOM Document. 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.

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 is template-driven, 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.

XVRL (eXtensible Value Resolution Language)

Developer: xvrl.org
URL: http://www.xvrl.org/
License:
Database type: Relational (JDBC)
Direction(s) : Database=>XML

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

2.2 XML-Enabled Databases

XML-Enabled Databases are databases (usually relational) that contain extensions (either model- or template-driven) for transferring data between XML documents and themselves. XML-Enabled Databases are generally designed to store and retrieve data-centric documents. This is because data is transferred to and from user-defined tables, rather than tables specifically designed to model XML documents. However, many of them can store document-centric documents in a single column and use text-processing extensions for queries.

Because many databases can publish documents to the Web, the line between XML-Enabled Databases and XML Servers is blurry, although the latter seem designed primarily for building Web-based applications. Less blurry is the line between XML-Enabled Databases and XML Application Servers (which cannot receive data as XML) and Content Management Systems (which are generally used for storing document-centric documents and contain features such as editors and version control). For differences between XML-Enabled Databases and Native XML Databases, see Native XML Databases.

DB2 XML Extender and DB2 Text Extender

Developer: IBM
URL: http://www-4.ibm.com/software/data/db2/extenders/xmlext.html,
http://www-4.ibm.com/software/data/db2/extenders/text.htm
Database type: Relational

The DB2 XML Extender is a DB2 UDB Extender for transferring data between XML documents and DB2. XML DTDs are mapped to relational schema (and vice versa) with the XML-based Data Access Definition (DAD) language. The language comes in two flavors: SQL mapping and RDB node mapping. SQL mapping is a template-based language and can only be used to transfer data from the database to an XML document. RDB node mapping is a model-based language and uses an object-relational mapping. It can be used to transfer data both to and from the database. A visual tool is provided for constructing DAD documents -- that is, mapping elements and attributes to tables and columns.

Applications use stored procedures to invoke the extender, which then stores or retrieves data based on the DAD document. The XML Extender manages DAD documents and DTDs in its own tables, saving applications from having to do this and optimizing access.

The DB2 Text Extender contains a variety of search technologies, such as fuzzy searches, synonym searches, and searches by sentence or paragraph that can be used when an XML document is stored in a single column.

Informix

Developer: Informix (now owned by IBM)
URL: http://www.informix.com/idn-secure/webtools/ot/, http://www.informix.com/datablades/dbmodule/informix1.htm
Database type: Relational

Informix supports XML through its Object Translator and through the Web DataBlade.

The Object Translator generates object code, including the ability for objects to transfer their data to and from the database. It also supports functionality such as transactions and optimistic and pessimistic locking. XML support is provided through generated methods that transfer data between objects and XML documents. A GUI tool allows users to create object-relational mappings from XML documents to the database, also specifying how to construct intermediate objects. Version 2.0 of the Object Translator (beta expected in Sept. 2000) is expected to support SOAP as well as be able to generate XML DTDs from object schema and relational schema.

The Web DataBlade is an application that creates XML documents from templates containing embedded SQL statements and other scripting language commands. It is run from a Web server and supports most major Web server APIs.

Microsoft SQL Server 2000

Developer: Microsoft
URL: http://msdn.microsoft.com/library/periodic/period00/sql2000.htm (see "XML Support" section),
http://msdn.microsoft.com/library/periodic/period00/thexmlfiles.htm
Database type: Relational

Microsoft SQL Server 2000 supports XML in three ways: the FOR XML clause in SELECT statements, XPath queries that use annotated XML-Data Reduced schemas, and the OpenXML function in stored procedures. SELECT statements and XPath queries can be submitted via HTTP, either directly or in a template file.

The FOR XML clause has three options, which specify how the SELECT statement is mapped to XML. RAW models the result set as a table, with one element (named "row") returned for each row. Columns can be returned either as attributes or child elements. AUTO is the same as RAW, except that: 1) the row elements are named the same as table name, and 2) the resulting XML is nested in a linear hierarchy in the order in which tables appear in the select list.

EXPLICIT allows you to model an XML document using a series of SELECT statements that are UNIONed together. In its simplest form, each SELECT statement is numbered and includes the number of its parent statement. The results of an individual statement are modeled as a table and an element is created for each row. This is placed in the XML document beneath the appropriate parent element. Assuming there is a relation between the result sets (for example, each contains a sales order number), the children are nested as one would expect. EXPLICIT allows you to create canonical object-relational mappings from the database to an XML document, but supports more sophisticated queries as well.

Annotated XML-Data Reduced schemas, also known as mapping schemas, contain extra attributes that map elements and attributes to tables and columns. These specify an object-relational mapping between the XML document and the database, and are used to query the database using a subset of XPath. A tool exists to construct mapping schemas graphically.

The OpenXML function uses a table-based mappig to extract any(?) part of an XML document as a table and use it in most places a table name can be used, such as the FROM clause of a SELECT statement. This can be used in conjunction with an INSERT statement to transfer data from an XML document to the database. An XPath expression identifies the element or attribute that represents a row of data. Additional XPath expressions identify the related elements, attributes, or PCDATA that comprise the columns in each row, such as the children of the row element.

Inserts, updates, and deletes are done through specially formatted XML documents called "updategrams". These contain the before and after data (both in the case of update, only after data in the case of insert, and only before data in the case of delete). By default, updategrams use table-based mappings. They can use object-relational mappings by specifying an annotated schema.

Oracle 8i, 9i

Developer: Oracle
URL: http://technet.oracle.com/tech/xml/info/htdocs/relational/index.htm#ID795,
http://technet.oracle.com/docs/products/ifs/doc_index.htm (registration required),
http://technet.oracle.com/products/intermedia/
Database type: Relational

Oracle 8i can store XML documents in three different ways: in the Internet File System (iFS), using the XML SQL Utility for Java, and as a BLOB that can be searched using the Oracle Intermedia XML Search. Oracle 8i also includes a number of other XML-related tools, the most interesting of which is the XML Class Generator, which can generate Java classes from a DTD.

With iFS, one or more type definition (mapping) files define an object-relational mapping from the XML document to the database. iFS uses these mapping files both to construct tables in which the XML document can be stored, and to transfer data between XML documents and the database. Of interest, iFS can return data from the database directly as objects instead of XML documents, which is useful to many applications. iFS also supports content management features such as check-in/check-out and versioning.

The XML SQL Utility for Java was described above. When it is used with Oracle 8i, it uses an object-relational mapping, since Oracle 8i supports SQL 3 object views.

Oracle Intermedia XML Search is a utility that can (in the words of the Web site), "Automatically index and search XML Documents and Document Fragments of any size up to 4 Gigabytes each. [It has] powerful XML document searching including hierarchical element containership, doctype discrimination, and searching on XML attributes."

Oracle 9i (announced 2 Oct, 2000) includes "Native XML Database Support (XDB)", which introduces a new object data type (XMLType) and "features ... 'navigational' access and search for XML documents."

2.3 Native XML Databases

Native XML databases fall into two broad categories:

There are two major differences between the two strategies. First, text-based storage can exactly round-trip the document, down to such trivialities as whether single or double quotes surround attribute values. Model-based storage can only round-trip documents at the level of the underlying document model. This should be adequate for most applications but applications with special needs in this area should check to see exactly what the model supports.

The second major difference is speed. Text-based storage obviously has the advantage in returning entire documents in text form. Model-based storage generally has the advantage in returning fragments of documents or combining fragments from different documents, although this does depend on factors such as document size, parsing speed (for text-based storage), and retrieval speed (for model-based storage). Whether it is faster to return an entire document as a DOM tree or SAX events probably depends on the individual database, again with parsing speed competing against retrieval speed.

Native XML databases differ from XML-Enabled databases in three main ways:

Native XML Databases differ from XML Servers and XML Application Servers for the same reasons that XML-Enabled Databases differ from those systems. Native XML databases differ from Content Management Systems in that Content Management Systems are generally front-ends to native XML databases, tailored specifically for managing document-centric documents and offering features such as editors, check-in/check-out, and so on.

4Suite, 4Suite Server

Developer: FourThought
URL: http://www.4suite.org/4SuiteIndex.html
http://www.4suite.org/documents/guides/4SuiteServer/GeneralProgrammersGuide
Database type: Object-oriented

From the Web site:

"4Suite is a collection of Python tools for XML processing and object database management. It provides support for XML parsing, several transient and persistent DOM implementations, XPath expressions, XPointer, XSLT transforms, XLink, RDF and ODMG object databases."

"4Suite Server builds on 4Suite to provide a complete platform for XML processing. It features an XML data repository, a rules-based engine, and XSLT transforms, XPath and RDF-based indexing and query, XLink resolution and many other XML services. It also supports related services such as distributed transactions and access control lists. Along with basic console and command-line management, it supports remote, cross-platform and cross-language access through CORBA, WebDAV, HTTP and other request protocols to be added shortly."

Birdstep DataBase Engine

Developer: Birdstep
URL: http://www.birdstep.com
Database type: Proprietary (viewable as Relational, Object-Oriented, Hierarchical, etc.)

Birdstep DataBase Engine (Birdstep DBE) is an "ultra small" database (less than 60K) that can "store and manipulate any type of data (text, numeric, spatial, graphical, etc.)". It supports "dynamic schema evolution", object inheritance, encapsulation and polymorphism, and "ultrafast" vector search, with size independent performance (log(N)). The stored data is binary compatible across platforms and can be moved from one device to another device (independent of hardware or operating system).

Birdstep stores data as "molecules", each of which consists of two or three "atoms": a content atom (which contains the actual data value when it is longer than 4 bytes), an instance atom (which contains data values of 4 bytes or less, or pointers to data values longer than 4 bytes), and a type atom (which defines the type of an instance atom). There are several interesting things to note here. First, no data longer than 4 bytes is stored more than once. Second, content atoms contain pointers to all instances, so they serve as indexes. Third, chains of instances and links between chains allow Birdstep DBE to store virtually any kind of data structure, including XML.

Birdstep DBE supports XML in several ways, using a storage model that is similar to DOM objects. SAX can be used both to read and write XML documents, with the database acting as a DocumentHandler in the first case and a Parser in the second. (A C++ SAX implementation is used, which necessarily deviates slightly from the Java interfaces.) Applications can also use expat to store documents and an XML generator to retrieve them. Finally, an internal interface (IBXML) can be used by applications in "special circumstances". An XPath implementation (used to address parts of an XML document) and a DOM implementation over the database are to be released soon.

DBDOM

Developer: K. Ari Krupnikov
URL: http://sourceforge.net/projects/dbdom/
Database type: Relational

DBDOM is an Open Source implementation of the DOM over a relational database, using a fixed set of tables to store the DOM tree in the database. DOM methods are implemented as stored procedures, but also included are a set of adapters so these can be called from Java. The initial version will run on PostgreSQL, with later versions planned for Oracle, DB2, and Microsoft SQL Server.

dbXML

Developer: The dbXML Group
URL: http://www.dbxml.org/overview.html
Database type: Proprietary (Model-based)

From the Web site:

"...the industry's first Open Source Native XML Database Application Server. It has been designed from the ground up as a complete solution to enterprise-wide XML integration and application provisioning. dbXML will be available in two flavors, the Core Edition and the Enterprise Edition."

"The dbXML Core Edition is a data management system designed specifically for collections of XML documents. It is easily embedded into existing applications, highly configurable, and openly extensible. It is released under the terms of the GNU Lesser General Public License (LGPL)."

"The commercial version of dbXML, the dbXML Enterprise Edition, will feature a suite of functionality geared specifically toward client-connectivity and business logic encapsulation. Some of this functionality will include CORBA services, management tools, and JDBC(TM) drivers for legacy connectivity."

An early version of the Core Edition is currently available. [Oct. 2000]

eXcelon Extensible Information Server

Developer: eXcelon Corp.
URL: http://www.exceloncorp.com/platform/extinfserver.shtml
Database type: Object-oriented (ObjectStore). Relational data through ODBC and OLE DB

eXcelon is designed to be used in conjunction with a Web server to send and receive XML documents across the Web. It stores XML documents in Object Design's ObjectStore database (apparently) as DOM trees. These are indexed and can be queried through XQL. In addition, the database can be used to store XQL queries, files (such as multi-media documents), and Java classes. The latter are written by users to implement server-side applications; they can access XML documents through the DOM and through XQL.

eXcelon can also import data from relational databases (through ODBC and OLE DB) and the file system. This is especially important when it acts as a cache for back end data sources. It uses a "Cache-Forward architecture" to allow data to be cached in application servers, with a "patented call-back locking algorithm" to guarantee transactional consistency of the back end(?) data. One advantage of this is that XML documents built from back end data and cached in eXcelon do not need to be reconstructed when served to the Web.

eXcelon comes with a GUI administration tool, XML Explorer (for exploring XML documents stored in eXcelon, importing and exporting documents from the file system or back end databases, and visually building XQL queries), and eXcelon Studio (for defining DCD XML schemas and "automatically generating forms, HTML pages, and Java classes for manipulating XML data according to the defined DCD schema").

eXist

Developer: Wolfgang Meier
URL: http://exist.sourceforge.net
Database type: Relational

From the Web site:

"eXist is a repository and retrieval engine for XML documents build on top of an rdbms (MySQL and Oracle). It provides structured retrieval of documents with support for fulltext search. All documents may be queried at the same time, regardless of the DTD."

Open Source.

GoXML DB

Developer: XML Global
URL: http://www.xmlglobal.com/prod/foundation/goxmldb.jsp
Database type: Proprietary (Text-based)

GoXML DB contains four core components: the Storage Manager, the Index System, the XPath Query Engine, and a Java API. GoXML DB can be deployed as a stand-alone XML repository, or combined with other products such as GoXML Search and GoXML Transform.

The Storage Manager stores XML documents as text in a proprietary data store. This "ensures that document structures and relationships are kept intact during any operation." It supports multiple, concurrent sessions, as well as session pooling, and recycles free space automatically, so compaction is not required. In addition, it allows partial document updates and document fragment insertion.

The Index System creates and maintains indexes over attribute and element values. These are used by the XPath Query Engine, which supports XPath with proprietary extensions. Queries are optimized to select the best combination of indexes, and complex query support includes "AND and OR predicate processing", as well as "support for complex XPath predicates."

Transaction support includes read, write, and update locks, as well as deadlock detection and victim selection. Commits and rollbacks are supported so that the system can recover in the case of a crash.

Of note, the Java API includes the ability to bind result sets to single or vector-based variables, making it easier to map XML to objects.

Infonyte XQL Suite (formerly PDOM)

Developer: Infonyte
URL: http://xml.darmstadt.gmd.de/xql/index.html
http://www.infonyte.de/
Database type: Proprietary (Model-based)

The Infonyte XQL Suite provides an implementation of the DOM over indexed, binary files (the PDOM, or Persisten DOM). These are created by converting existing XML documents (a one-time operation), as well as when PDOM is used to create a new DOM Document. PDOM includes a cache, which swaps DOM nodes to disk when handling large DOM trees, defragmentation and garbage collection facilities, commit points (for writing the in-memory tree to disk), file compression with gzip, and thread-safe operation.

The XQL Suite also includes an implementation of XQL, which users can extend with custom operators and methods, and servlet versions of the DOM and XQL implementations.

Ipedo XML Database

Developer: Ipedo
URL: http://www.ipedo.com/
http://www.ipedo.com/Ipedo_XML_DB_Datasheet.pdf

Not yet reviewed.

Lore

Developer: Stanford University
URL: http://www-db.stanford.edu/lore/home/index.html
Database type: Semi-structured

Semi-structured data is data with more structure than a conversation, but less structure than a telephone book. A good example is a resume (curriculum vitae). While virtually all resumes include a name, address, and telephone number, only some will include an email address, Web site, or FAX number. Most will include a list of previous jobs, but others might include only a list of university courses. Depending on the profession, there might be a list of software used or licenses held.

XML is well-suited to storing semi-structured data and shares a feature common to many semi-structured data models: it is self-describing. That is, it carries a certain amount of metadata with the data. In the case of XML, this is in the form of element type and attribute names. The legality of well-formed documents mirrors another feature found in many semi-structured data models: the data model is not required to have a definitive schema, and the model can be extended at will by the addition of new fields.

Lore is a database designed for storing semi-structured data. Although it predates XML, it has recently been migrated for use as an XML database. It includes a query language (Lorel), multiple indexing techniques, a cost-based query optimizer, multi-user support, logging, and recovery, as well as the ability to import external data. Because Lore is designed for use with semi-structured data, XML documents without DTDs can be easily stored.

An interesting feature of Lore is a DataGuide, which is a "structural summary of all paths in the database". Unlike structured databases, in which the structure is specified first and data is added according to that structure, data is entered first into Lore and the structure is then summarized. The resulting information useful for query processing.

The Lore executables are "available for public use". Source code may be available in some circumstances.

Natix

Developer: data ex machina
URL: http://www.dataexmachina.de/natix.html

Not yet reviewed.

Neocore XML Management System

Developer: NeoCore
URL: http://www.neocore.com/products/products.htm
Database type: Proprietary

From the company:

"NeoCore XML Management System (XMS) is a fully transactional native XML database system that serves as a bi-directional web server, accepting and returning XML documents and fragments via HTTP(S). It supports all basic database functions, including storage, delete, copy, and query for XML documents, and insert, modify, and query for XML data elements. NeoCore XMS is schema-independent and requires no database or schema design before using the system. That is, rows, columns, tables, fields, or indexing instructions do not need to be created before documents are added to the database. When new documents are added to the database, their structure and data - metadata and data - are derived and automatically indexed. Users then can change the structure of existing documents without database system redesign. Specific features of NeoCore XMS include XPath-based query support, access control, user-defined document data management, GUI-based administration, and session control."

"NeoCore XMS uses a variant of XPath as its query language; query responses return elements, document fragments, full documents, and multiple documents. Queries can be made without knowing the document structure - context can be queried for data, and data can be queried for context. Boolean and wildcard options are fully supported and all query results are well-formed XML. For query processing, NeoCore XMS uses Digital Pattern Processing, a patented technology that streamlines queries by using fixed-length icons."

"NeoCore XMS has built-in access control to set permissions at the document or fragment level, and at user or group levels. NeoCore XMS also supports access control by specifying IP addresses and supporting X.509 certificates via Netscape Server."

"Interfaces to NeoCore XMS include HTTP(S)/SSL, Java, C++, and Microsoft COM. NeoCore XMS also can interface with existing databases through the X-Aware data integration tool."

ozone

Developer: ozone-db.org
URL: http://ozone-db.org/ozone_main.html
Database type: Object-oriented

ozone is an Open Source object-oriented database completely implemented in Java. It supports transactions, object-level access rights, RMI, multi-user access, and multi-threading and comes with an implementation of the DOM.

SIM (Structured Information Manager)

Developer: RMIT MDS Group
URL: http://www.simdb.com/simdb%20content%2FAbout%20SIM
Database type: Proprietary

From the Web site:

"SIM is designed to support applications where the content is more valuable than the system that surrounds it. Standards are therefore central to the SIM philosophy. Due to the modular architecture, the various SIM components can be used separately for particular applications. More commonly however, the full range of products are used together to build complex applications. Highlights of SIM include:

o Extensive SGML/XML support;
o Full text indexing;
o Powerful web application development tools;
o High performance components."

Tamino

Developer: Software AG
URL: http://www.softwareag.com/tamino/
Database type: Proprietary. Relational through ODBC.

Tamino consists of an engine (the X-Machine), an internal XML data store, a relational database and SQL engine, a module (the X-Node) for interfacing to external data sources, such as relational databases and file systems, an HTTP server, administration tools, and a data map. The latter describes where the data in a given XML document is stored and allows XML documents to be composed from multiple, heterogeneous sources.

Tamino's XML support includes a DOM implementation, an XQL implementation, processing of XML documents with XSL and CSS, and limited support for SOAP. It can store schema-less documents and can use schema information if it is available.

The internal SQL engine is directly addressable through ODBC, JDBC, and OLE DB. However, when addressed via these APIs, it cannot integrate data from the internal XML data store or from external data sources. (As noted above, the reverse is true. That is, with the help of the X-Node, the X-Machine can integrate data from the XML data store and other databases, including the internal SQL engine.)

(Note: In spite of rumors to the contrary, Tamino is not built on top of Adabas, a hierarchical database from Software AG. Instead, the Tamino data store was built from the ground up as a native XML database, obviously drawing on the knowledge gained from developing Adabas.)

TEXTML Server

Developer: IXIA, Inc.
URL: http://www.ixiasoft.com/Products/TEXTMLServer/frame-text.asp
Database type: Proprietary (Text-based)

TEXTML Server is designed as a high-volume server of XML documents. It does not decompose the native XML instance, but instead parses it and builds indexes based on markup. This preserves the physical structure of the document (entity references, CDATA sections, etc.). In addition, it can store non-XML documents; these are not indexed and can be retrieved only by name or by reference from an XML document (presumably as an unparsed entity). Finally, it offers a check-in/check-out system.

XML documents can be searched using dates or date intervals (for dates that appear in the text), character strings, or full text retrieval. TEXTML Server also supports proximity operators and can sort the results.

TEXTML Server is a series of COM objects that run inside Microsoft Transaction Server (MTS). It comes with an Active Server Pages (ASP) toolkit.

Virtuoso

Developer: OpenLink Software
URL: http://www.openlinksw.com/virtuoso/
Database type: Proprietary. Relational through ODBC

Virtuoso is a heterogeneous join engine featuring security, transactions (including two-phase commit), and replication. Its query engine supports heterogeneous views, stored procedures, scrollable cursors, and full text search. It accesses external data sources through ODBC, as well as having its own relational data store.

Virtuoso supports XML in a number of ways. First, it contains a native XML data store, which is non-relational and can store and index XML documents in parsed or unparsed form. Second, it can transfer data from relational databases to XML documents (although not the other direction), using the same mapping found in the FOR XML clause in Microsoft SQL Server. Third, it includes an implementation of XPath. Although this only works on "native" XML data, relational data can be included by first transferring it to XML. Finally, it includes support for XSLT, executing stored procedures through SOAP, and WebDAV.

XDBM

Developer: Bowerbird Computing
URL: http://www.bowerbird.com.au/XDBM/
Database type: Proprietary (Model-based)

XDBM uses an interface that is "based upon the DOM standard". It stores XML documents in a pre-parsed, indexed format and resolves memory problems by leaving parts of the document on disk until they are needed.

XDB

Developer: ZVON.org
URL: http://zvon.org/index.php?nav_id=61

Not yet reviewed.

XDisect

Developer: PyBiz
URL: http://www.pybiz.com/products/xdisect/

Not yet reviewed.

Xfinity Server

Developer: B-Bop Associates, Inc.
URL: http://www.b-bop.com/products.htm
Database type: Relational. Others through "data connectors".

Xfinity Server provides native XML document storage over any relational database. It stores XML documents as discrete elements and does not require documents to have a DTD or schema. A query engine is used to index documents and retrieve entire documents or document fragments; returned documents can be transformed with a built-in XSLT engine. Xfinity server can also retrieve data from external relational databases, HTML documents, flat files, and Word and Excel documents. The query language used, as well as the APIs used for the native store and external databases, is not specified.

X-Hive/DB

Developer: X-Hive Corporation
URL: http://www.x-hive.com/
Database type: Object-oriented (Objectivity/DB)

X-Hive/DB is a native XML database. XML support includes DOM level 2 (including extensions for manipulating multiple documents), an XPath implementation, and an XSLT engine. Relational data is available through the SQL Loader, which apparently retrieves data at run-time with JDBC. Additional X-Hive/DB features are transaction support, a distributed architecture (allowing data to be distributed across multiple servers), user- and group-level access control, a data browser, and administration tools.

XML Agent, Yggdrasill

Developer: Media Fusion
URL: http://210.225.238.61/agent-e/agent.htm
http://www.mediafusion.co.jp/xml-e/ygg/ygg.htm
Database type: Relational

Not yet reviewed. XML Agent (currently available) is a prototype of Yggdrasill (not currently available).

XYZFind Server

Developer: XYZFind Corporation
URL: http://www.xyzfind.com/product/
Database type: Proprietary

From the company:

"XYZFind Server provides storage, search, and query for XML documents. It automatically indexes well-formed XML documents without requiring a DTD or schema. When a document is added to the database, it is decomposed into a persistent, parsed structure, which is used to reconstruct the entire document for retrieval. Documents are round-tripped with respect to the XPath data model and the rules for non-validating XML parsers. The storage mechanism is derived from search engine technology, extending the traditional inverted index. Keywords, numbers, and "nodes" (elements, attributes, text, comments, processing instructions, and namespace declarations) are all included in the index."

"XYZFind Server uses a proprietary, XML-based query language (XYZQL) to add, replace, delete, search, and query documents in the database. XYZQL provides similar query functionality to that of XPath and XQL, with the addition of support for numeric-range and full-text keyword search. It provides equivalents to XPath's child, descendant, and attribute axes. Like XPath, it supports queries that use wildcards and boolean constraints, and queries that return document fragments. Unlike XPath, it is expressed in XML syntax and does not support equivalents to all of the XPath axes."

"XYZFind Server functions as an HTTP server, supporting GET requests for retrieving documents, PUT requests for adding/updating documents, and POST requests for sending XYZQL commands. It also supports the bulk indexing of zip files that contain XML documents. The server supports concurrent reads and writes to the database."

"The XYZFind distribution comes with a sample client and Java API (including source code) that serves as a wrapper for the HTTP interface."

2.4 XML Servers

XML Servers are platforms for serving data to and receiving data from distributed applications, such as e-commerce and business-to-business applications. Data is transferred in the form of data-centric XML documents, although some systems can also serve document-centric documents. XML Servers generally contain complete application development environments and provide access to data in a variety of data stores, including legacy databases, email messages, and file systems.

The line between XML Servers and XML-Enabled Databases and Native XML Databases is blurry, as the latter usually can also access a variety of data stores and connect to the Web. Those systems I have classified as XML Servers are ones that portray themselves as platforms for building e-commerce and other distributed applications, rather than strictly as databases, which obviously can be used to develop such applications. The line between XML Servers and XML Application Servers is also blurry; those systems I have categorized as XML Application Servers tend to be driven by scripting languages or custom markup languages and generally sit on top of a Web server.

Castor

Developer: exolab.org
URL: http://castor.exolab.org/index.html
Database type: Relational (JDBC)

Castor is Open Source project that is "the shortest path between Java[tm] objects, XML documents, SQL tables and LDAP directories. It provides Java to XML binding, Java to SQL/LDAP persistence, and then some." It supports optimistic and pessimistic locking modes, in-memory concurrency engine, and dead-lock detection, as well as support for Enterprise Java Beans, JTA transaction demarcation, inclusion as resource in transactional environment, and JDBC connection pooling.

Castor supports XML through its ability to transfer data between XML documents and Java objects and between Java objects and relational databases. Mappings are specified with an XML-based mapping language that defines an object-relational mapping and supports one-one and one-many relation types, SQL/Java inheritance, object graph to single row mapping, multiple column primary keys, and automatic type conversion. In addition, a code generator can generate classes from XML Schema documents.

Work is under way on a component to transfer data directly between XML and relational databases without intermediate Java objects.

MatriXML

Developer: MojoTechnology, Inc.
URL: http://www.mojocommerce.com/ (requires Flash)
Database type: Oracle. External relational through ODBC

MatriXML is a Web server add-on used to store and retrieve XML documents via the Web. Documents are stored in an Oracle database using a proprietary set of tables that model the logical structure of XML documents. Before documents can be stored, users must first define their DTD to the database; this is done through browser-based tools. With the same set of tools, users can also define the XSL or CSS style sheet (if any) to be used when displaying the document.

XML documents are retrieved from the database via URL. They are sent to the database either via a browser screen or as complete XML documents. Users can also update and delete XML documents via browser screen.

In addition to containing static data, XML documents can contain data from one or more ODBC databases; the mapping from ODBC to XML is not specified.

Of interest, all structure, content, and formatting is versioned and archived. Furthermore, MatriXML has been designed to meet the requirements of the US Food and Drug Administration (FDA) for electronic signatures and electronic record handling.

Full commercial release is scheduled for September 2001. However, releases with a limited feature set should be available by the end of 2000. Contact the company for details.

PowerXML Server and PowerXML Pro

Developer: Wizen Software
URL: http://www.wizen.com/new2/PowerXML.html
Database type: Relational

Not yet reviewed.

Rhythmyx Integrator

Developer: Percussion Software
URL: http://www.percussion.com/rhythmyx/xml.htm
Database type: Relational (JDBC, ODBC)

Rhythmyx Integrator is a Web server that runs database-driven applications. Developers define these applications with Rhythmyx Workbench, a GUI tool that defines how data is processed. As input, developers pass HTML pages that have been labeled with which fields contain dynamic data -- that is, data from the database. A utility (XSpLit) then generates an XML document and an XSL document from the marked-up HTML and the developer maps the database fields to the XML document. Finally, the developer indicates any additional processing, such as whether the data may be inserted, updated, or deleted in the database, whether any Java code is to be executed immediately before or after calls to the database, and so on. It is not clear in what form data is accepted from the Web (XML documents, HTML form values, etc.)

It appears that the XML document is mapped to the database with an object-relational mapping, with the ability to insert grouping elements. (For example, suppose an Employee table is mapped to the Employee element. The FirstName and LastName columns could be mapped to FirstName and LastName elements, grouped inside a Name element that is a child of Employee.) Of interest, Rhythmyx Integrator can perform heterogeneous joins -- that is, it can join data from different databases -- and update data in multiple, heterogeneous tables.

Total-e-Business (formerly Bluestone XML-Server)

Developer: HP Bluestone
URL: http://www.bluestone.com/products/total-e-server/default.htm
Database type: Relational (JDBC). Non-relational through Data Source Integration Modules

Total-e-Business is a J2EE (Java 2 Enterprise Edition) application server, at the heart of which is an Enterprise Java Beans (EJB) object server (the Universal Business Server). Applications are built from EJBs and run in the context of the object server, which provides resources for handling transactions, persistence, etc. A typical Web-based application is constructed of Java Server Pages (JSPs), which use EJBs to perform various tasks.

XML is used in Total-e-Business applications in several places. First, it can be used as the interface between EJBs and JSPs. That is, a JSP can populate an EJB using data in an XML document. Similarly, an EJB can pass data to a JSP as an XML document. In the latter case, the XML can be transformed by XSLT (such as to an HTML or WML document) or sent directly to a browser on the Web. (It is not clear whether the JSP can receive data from the Web in the form of an XML document. If so, it could be passed directly to the EJB.)

The second way in which XML is used is to persist EJBs. In this case, the EJB's data is persisted to an XML document, which is then passed to the Bluestone XML-Server to be stored in a database. The XML document is mapped to the database with an object-relational mapping, which allows it to contain deeply nested elements that are stored in multiple tables. (EJBs can also be persisted directly to the database using JDBC, but this requires hand-coding.)

The third way in which XML is used is in "XML applications". These consist of an application class and one or more document handlers. The application class receives incoming XML documents and passes them to document handlers for processing. It also sends XML documents back to clients, such as Web browsers or other XML applications. XML applications use the Bluestone XML-Server to transfer data between XML documents and relational databases.

Total-e-Business can be purchased in a number of different configurations (Total-e-B2C, Total-e-B2B, Total-e-Server, Total-e-Global), all of which include the object server and XML server. It also comes with numerous development tools (including a tool for mapping between different DTDs that model the same data) and sample applications.

Versant enJin

Developer: Versant Corp.
URL: http://www.versant.com/products/enjin/datasheet.html
Database type:

Versant enJin is a middle-tier data store that integrates with existing Enterprise Java Bean (EJB) servers. It is used to persist Java objects and EJBs, as well as "intermediate data", such as the "state of ongoing business workflows, data about user sessions and interactions, or meta-data." Features include caching across multiple application servers, synchronization with the back-end relational database, replication, and notifications.

Versant enJin supports XML through its ability to convert graphs of Java objects to and from XML documents. This is useful both for using XML as a data transport in distributed applications and as a way to more easily manipulate XML documents by first converting them to objects.

XA-BizDoc Server

Developer: XAware, Inc.
URL: http://www.xaware.com/software_overview.htm
Database type: Relational (ODBC), others through user-written drivers

The XA-BizDoc Server is a Web application server (or standalone Web server) that serves XML documents to, and receives XML documents from, the Web. Each XML document is mapped to one or more data sources by a business document, or BizDoc. This maps the XML document to the database with an object-relational mapping, with the ability to insert grouping elements. (For example, suppose an Employee table is mapped to the Employee element. The FirstName and LastName columns could be mapped to FirstName and LastName elements, grouped inside a Name element that is a child of Employee.)

What is interesting about BizDocs is that the mappings are modular. That is, a given BizDoc is composed of a tree of business components, or BizComps. Each BizComp contains the information needed to map a set of elements to a given data source. Not only can each BizComp in a given BizDoc use a different data source, BizComps can be reused in different BizDocs.

For example, suppose an XML document represents a purchase order. At the top level is purchase order header information, such as purchase order number and date. Nested inside this could be customer information as well as multiple purchase order items. This could be processed by three different BizComps: one for the purchase order header information, one for the customer information, and one for the items. The BizComps for header information and items might store this data in the PurchaseOrders and PurchaseItems tables in one database, while the BizComp for customer information might store the customer data in a Customers table in a separate database. Thus, if you needed to define a BizDoc for an XML document that contained only customer information, you could reuse the customer BizComp.

XA-BizDoc Server comes with BizComp drivers for ODBC, ADO, and Microsoft JET. Users can write their own drivers for other data sources, such as email or enterprise applications such as PeopleSoft.

XML Portal Server (XPS)

Developer: Sequoia Software Corp.
URL: http://www.sequoiasw.com/xps/index.asp,
http://www.sequoiasw.com/xps/xpstechnical.pdf (~5 MB, worth reading)
Database type: Various

XML Portal Server (XPS) provides XML-driven business processes and XML-based content delivery. Although the lines can blur between the two, they are most easily viewed separately.

Business processes are implemented as a user-defined series of actions on a business object (XML document). The XML document may come from an external source (such as an external application or the Web) or be constructed from data in a database. A dispatcher controls the flow of the document from action to action based on user-defined rules, which use XPath expressions to identify data in the document. Actions, such as ordering new parts based on current inventory, storing the data in the document in a database, or simply indexing the document, are carried out by "integration agents"; users can use pre-defined agents or write their own. All business processes occur within a Microsoft Transaction Server (MTS) transaction.

Content delivery is provided through Content Delivery Agents (CDAs). CDAs are typically written in JavaScript or VBScript and control how an XML document is assembled. For example, the script might retrieve data from a database, integrate content from an Internet content provider such as CNBC, or associate a certain style sheet based on the value of retrieved data. The XML document can then be formatted with a stylesheet before being sent to the client. XPS comes with a number of pre-defined CDAs.

In addition to communicating with external databases, XPS can gather, aggregate, and/or index content through "Smart Spiders" and store the results in a local repository.

2.5 XML Application Servers

XML Application Servers are Web application servers that are able to serve both data- and document-centric XML documents to the Web. They are generally template-driven, using embedded SQL statements in a scripting language to retrieve data and dynamically build XML documents. (Web application servers are really just high-volume applications that use the Web for their user interface. They plug into a Web server, which handles communcation with the Web, delegates tasks, and serves static documents that no application servers handle.)

The line between XML Servers and XML Application Servers is blurry; those systems I have categorized as XML Application Servers tend to be driven by scripting languages or custom markup languages and generally sit on top of a Web server. Although many Content Management Systems can also publish XML to the Web, they are fundamentally different in that they are designed to manage document-centric documents, while XML Application Servers serve both data-centric documents (in the form of dynamic Web pages) and document-centric documents (in the form of static Web pages).

AxKit

Developer: AxKit.com Ltd.
URL: http://axkit.org/
Database type: Relational (DBI)

AxKit is an XML application server for Apache. It works by checking requests to Apache to see if they are for XML documents. If so, AxKit takes over the processing; if not, it lets Apache continue with its processing.

AxKit processing is done by one or more PERL modules. These can do anything from simply applying an XSL stylesheet to retrieving data from a database. The modules can be chained together in UNIX pipe-like fashion using one of three models. First, the XML document can be passed from one module to the next as a DOM tree. Second, it can be passed as a text string representing the document. Third, the modules can be set up like SAX filters, with each module acting as a SAX application for the previous module and a SAX parser for the subsequent module.

AxKit comes with a number of pre-built modules, including two different XSLT processors, an XPathScript module, and a PERL XSP implementation, which provides database access. (For more information about XSP, see Cocoon.)

Cache

Developer: InterSystems Corp.
URL: http://cache.intersys.com/cache/edbms.html
Database type: Cache (Post-Relational)

Cache is a "post-relational" database that stores data in multi-dimensional arrays and provides SQL, object-oriented, and multi-dimensional access to that data. It can serve as a Web application server, where applications are composed of Cache Server Pages -- XML or HTML pages marked up with Cache Application Tags. Cache claims speed gains over other Web application servers on two grounds. First, the Cache database is faster than relational databases. Second, the Cache Server Pages are processed in the same process that the database runs in, eliminating the overhead of inter-process communication.

Cocoon

Developer: Apache.org
URL: http://xml.apache.org/cocoon/sqltaglib.html
Database type: Relational (JDBC)

Cocoon is an XML publishing framework for the Apache web server. Web pages are written in XSP (eXtensible Server Pages), a scripting language. This language contains an SQL tag library for retrieving data from relational databases with JDBC. Most of the tags contain configuration information, such as the database URL, or processing information, such as the number of rows to return from a SELECT statement. A query tag contains the SQL statement to execute; note that this can be any SQL statement, not just a SELECT statement.

If the statement is a SELECT statement, the results are returned as XML, where the XML is modeled as a single table. Users can specify the names of the elements that wrap each row, as well as the name of an element to wrap the entire result set. The names of elements for each column are taken from the result set; these can be specified with AS clauses in the SELECT statement. In addition, users can specify Java Format classes to format the output of a column.

ColdFusion

Developer: Allaire
URL: http://www.allaire.com/Products/ColdFusion/productinformation/
Database type: Relational (ODBC, OLE DB, Native drivers)

ColdFusion is a Web application server that can retrieve and update data on numerous sources, including databases (ODBC, OLE DB, and native drivers), email, and file systems. It includes an integrated development environment and supports object transaction middleware through COM, CORBA, and EJB.

ColdFusion is template-driven, with applications written in Cold Fusion Markup Language (CFML). This includes tags for inserting and updating data from forms, executing stored procedures, executing user-specified SQL statements (such as SELECT, INSERT, UPDATE, or DELETE), and starting, committing, and rolling back transactions. Users use special parameters to specify where data from result sets is placed in the document. It appears these can be used as parameters for other SQL statements, allowing nested queries to be constructed.

DataChannel Server (formerly Rio)

Developer: DataChannel
URL: http://www.datachannel.com/products/index.html
Database type: Relational through JDBC and ODBC

DataChannel Server is a tool for building and running Enterprise Information Portals (EIPs). (An EIP is a Web site that allows a corporation to expose information from a variety of sources -- documents, databases, email, and so on -- to its employees and allow those employees to modify that information, such as by editing documents. Think of Lotus Notes on the Web.)

DataChannel has three layers: data, application, and access. The data layer accesses data stored both internally and externally and exposes this to the application layer as an XML document. The data layer can convert over 200 "document types" (from Word to relational data) into XML documents. Each EIP has its own application layer, which must be built from Java servlets and XSL stylesheets. These access XML documents in the data layer using DOM. The access layer is any software that can read XML, such as a browser on a desktop or in a WAP-enabled cell phone. Changes made by users are sent back to the application layer using WebDAV (Web-based Distributed Authoring and Versioning -- an extension to HTTP).

Additional features include full-text search, notifications, and security.

Enhydra

Developer: enhydra.org
URL: http://www.enhydra.org
Database type: Relational (JDBC)

Enhydra is an Open Source Web application server. Applications are constructed of Java objects. There are three layers of objects: presentation objects (which generate content), application objects (which contain business logic and drive the application), and data objects (which transfer contain data and provide database access).

Enhydra differs from most Web application servers in that there is a separate Java class for each XML or HTML document. This separates presentation from application logic and is faster because documents are parsed at development time, not run time.

To create a presentation object, which is eventually served to the Web as an XML or HTML document, a developer marks up an XML or HTML document, adding an id attribute to each dynamic element. A program (XMLC) reads this and generates the code for the corresponding presentation class. This contains an initialization method that creates a DOM tree for the document, and accessor methods for each dynamic element. These return the element's Element node, which application objects can use to manipulate the element. For example, they can set the element's text to data from the database.

Enhydra comes with a number of development tools, such as XMLC and a GUI-driven module to map data objects to the database.

Lasso

Developer: Blue World Communications
URL: http://www.blueworld.com/blueworld/products/
Database type: Relational (ODBC, native drivers)

Lasso is a Web application server designed for building database-driven Web sites. Applications are built using marked-up Web pages, which may include Lasso-specific tags, JavaScript, and (I think) calls to Java programs. Lasso includes a GUI-based tool that runs in Macromedia Dreamweaver or Adobe GoLive and allows developers to graphically create Web pages.

Noetix Web Query

Developer: Aris Software, Inc.
URL: http://www.noetix.com/prod_ente_webq_NoetixWebQuery.asp
Database type: Relational (ODBC)

Noetix Web Query is a Web application server that retrieves data from "multiple, disparate databases" and returns results as XML documents. It is not clear if it can perform heterogeneous joins (probably not?), nor is it clear how results are formatted as XML. Noetix Web Query requires Microsoft IIS on the server and Internet Explorer 5.0 on the client.

Rhythmyx Content Manager

Developer: Percussion Software
URL: http://www.percussion.com/rhythmyx/content.htm
Database type: Unknown

Rhythmyx Content Manager is a Web server based on the same server as Rhythmyx Integrator. It can act either as a standalone Web server or a plug-in to an existing Web server and uses a user-supplied database as a document repository. No details are given on what databases are supported as repositories.

Web pages are designed using the Rhythmyx Workbench, which is described in the entry for Rhythmyx Integrator. Pages can be static, extracted from files such as PDF, Word, Excel, or comma-separated text files, created on the fly with data from JDBC or ODBC databases (including heterogeneous joins), or generated by Java code, which could, for example, pull the data from a live data feed. The result of assembling a page is an XML document, which can then be served directly to the Web or transformed with XSLT.

Rhythmyx Workbench can also be used to define the workflow required to create document, such as checking documents in and out or approving them for publication.

SQml Web and SQml Publisher

Developer: Agave Software Design
URL: http://www.agave.com/html/products/index.htm
Database type: Relational (ODBC)

A CGI application for serving database-driven HTML and XML documents. Data is retrieved through SQml Publisher, which is template-driven. It allows users to embed SQL statements in dynamic Web pages. The user then uses parameters to specify where the results of these queries will be placed. Note that they can be used as parameters in other SQL statements, allowing nested queries to be constructed. SQml Publisher can also be used as a stand-alone product for non-Web applications.

Zope

Developer: Digital Creations
URL: http://www.zope.org/,
http://www.devshed.com/Server_Side/Zope/Intro/,
http://www.zope.org/Wikis/zope-xml/User%20Doc%20for%20XMLDocument%20beta
Database type: Object-oriented, Relational (ODBC), Non-relational (LDAP, IMAP)

Zope is an Open Source Web application server. Unlike most Web application servers, Zope is really an object-oriented programming system, based on the Zope Object Database (ZODB). Developers can create and manipulate objects both through Python and through Document Template Markup Language (DTML). Each DTML document is therefore a separate object and DTML itself is closer to a programming language than it is to a simple tag set. It provides control-of-flow tags (if-the-else, loops, etc.) and allows users to create their own methods.

Developers use SQL to access relational databases. If the SQL statement is a SELECT statement, each row of the result set is returned as a Zope object. This may be accessed through Python or DTML. In the latter case, individual columns are accessed through parameters, and these may be placed whereever the user wants in the output document. These may be used to parameterize additional SQL statements, allowing nested queries to be constructed.

Zope supports XML in a number of ways. First, a DTML document can simply contain XML tags instead of HTML tags; this can be used, for example, to construct an XML document from relational data or data stored in ZODB. Second, existing XML documents can be stored in ZODB as XMLDocument objects. These can be manipulated with the DOM, transformed with XSLT, or returned to directly to clients as XML or HTML. Third, existing XML documents can be mapped to a tree of Zope objects according to an XSLT stylesheet. Fourth, ZDOM apparently allows any tree of objects in ZODB to be viewed/manipulated with a subset of the DOM. Finally, Zope supports XML-RPC and early third-party modules are available to use Zope with SOAP.

2.6 Content Management Systems

Content Management Systems are systems for storing, retrieving, and assembling documents from document fragments (content). They generally include such features as editors, version control, and multi-user access. Although they use a database, this is generally hidden from the user.

Content Management Systems differ from Native XML Databases in that they offer more document management functionality, such as version control. Most Content Management Systems can publish XML to the Web, but are different from XML Application Servers in that they are primarily designed to manage (document-centric) documents, while XML Application Servers are designed to serve both data- and document-centric documents to the Web.

Astoria

Developer: Chrystal Software
URL: http://www.chrystal.com/products/astoria/astoria.htm

From the Web site:

"... a content management solution for organizations producing technical publications and other kinds of structured documents. It works with your current authoring tools to provide fine-grained control over your valuable information assets. Commonly, these include a variety of graphics, illustrations, tables, Microsoft Word, and FrameMaker files, and often there is new media and structured file formats such as SGML and XML."

BladeRunner

Developer: Interleaf
URL: http://www.xmlecontent.com/products/brintro.htm

From the Web site:

"... enables companies to create, manage and publish e-content -- targeted, timely, personalized, intelligent and medium aware business information -- for their web enabled applications, using eXtensible Markup Language ("XML") as its technology backbone and Microsoft Word for content creation."

Content@XML (formerly Parlance Content Manager)

Developer: XyEnterprise
URL: http://www.xyenterprise.com/solutions/contentaxml.asp

From the Web site:

"... harnesses the power and flexibility of XML content in a simple yet comprehensive content management and workflow application. Supporting many popular XML editing applications, Content@XML manages structured XML source data at varying levels of granularity from individual objects to entire collections of content. Additionally, Content@XML provides extensive document management support for files from other applications such as graphics, text, audio, and visual content. ... In addition, your organization gets full revision and history tracking and the ability to roll back to earlier versions of any content component."

Documentum

Developer: Documentum, Inc.
URL: http://www.documentum.com/products/content/index.html

From the Web site:

"...an enterprise-wide solution for content authoring, management, reuse, web publishing and content interchange based upon XML. Key features of our native XML repository support include:
o Web-based templating for content creation
o XML authoring tool integration
o Automatic import and mapping of XML documents
o DTD and Schema Validation
o Configurable storage of XML documents
o Component and Link management support
o Powerful search capabilities across structure, content and metadata
o Dynamic XML document generation
o Transformation of XML documents (Integrated XSLT support)"

Dynabase

Developer: eBusiness Technologies (formerly Inso?)
URL: http://www.ebt.com/products/dynabase/index.htm

From the Web site:

"[Dynabase] combines sophisticated content management capabilities with a powerful, dynamic serving environment. Designed for use by distributed work groups throughout an organization, DynaBase brings control, extensibility, and automation to the e-business team. DynaBase enables authors, developers, production personnel, and managers to collaborate directly on Web site projects over the Internet and corporate intranet. It is designed to handle all types of content and work with a variety of editors, enabling e-business teams to easily select and use the best tools for each task."

engenda

Developer: eBusiness Technologies (formerly Inso?)
URL: http://www.ebt.com/products/engenda/index.htm

engenda is a "content management and workflow automation solution" that stores documents in an object-oriented database. Features include:
o Indexing of structured documents such as XML and HTML down to the tag level. Indexes are version- and edition-aware.
o Check-in/check-out with definable user privileges and check-in/check-out comments.
o Version control, including difference history.
o Arbitrary document metadata (name/value pairs).
o Editions (release points).
o Logical merging of separate content repositories.

Epic (formerly Adept)

Developer: Arbortext
URL: http://www.arbortext.com/Products/products.html

From the Web site:

"... helps you leverage the power of XML for content – "e-content" – by providing more personalized, dynamic and easily searchable content for e-publishing, e-service and e-marketplace applications. Epic does this by gathering content from multiple sources, converting it to a common format – XML – and dividing that content into intelligent, reusable components that it dynamically reassembles for multiple audiences and automatically transforms for multiple media, including the Web, print and wireless devices."

Of interest, Epic does not appear to have its own repository but can use a variety of other document management systems or databases for storage, including Chrystal, Documentum, Oracle, POET, Software AG (Tamino? Adabas?), STEP, SigmaLink, and Xyvision.

Frontier

Developer: UserLand Software
URL: http://frontier.userland.com/, http://frontier.userland.com/stories/storyReader$190

From the Web site:

"... an integrated Internet content system built around a high performance object database, outliner, scripting, and a multi-threaded runtime, built-in web server, editorial groupware and industry-leading syndication-aggregation and distributed computing technology. Link management, macros, rendered pages. ... Frontier can store, manage and generate XML-based information ... [and has] full support for XML-RPC."

GEM Content Management System

Developer: X.Systems, Inc.
URL: http://www.xsystemsinc.com/prodpres/gemtechbriefweb.htm

Not yet reviewed.

GroveMinder

Developer: TechnoTeacher
URL: http://www.techno.com/

From the Web site:

"...enables a comprehensive information framework that encompasses the entire organization. The framework allows information to flow seamlessly not only within a department, but throughout an organization, even among diverse databases and computer systems. GroveMinder is a document management system. It manages relationships between information objects (any piece of data or meta-data: documents, document components, databases, records, images, sensor output, etc.) With the GroveMinder system, all information objects, data and metadata alike, are equally easy to access."

Hynet Directive

Developer: Hynet Technologies
URL: http://www.hynet.com/Products/main.html

WARNING: This product might no longer be available as no server is registered for the URL www.hynet.com.

From the Web site:

"... the premier XML content management system for e-Business. It captures content created in familiar content creation applications such as Adobe FrameMaker, Macromedia Dreamweaver, Microsoft Word and XML, and transforms the data blocks (paragraphs, graphics, tables) within them into Information Units (IUs). These IUs are tagged and stored in a repository that can be accessed across the corporate environment with standard browsers. Using "drag and drop", IUs are recalled by virtue of their attributes (metadata assignment) and reused and re-purposed to create varied pieces of corporate collateral. The output can take the form of a web-site or print."

Information Manager

Developer: Interleaf
URL: http://www.xmlecontent.com/products/im.htm

From the Web site:

"... a comprehensive content and process management system for creating and managing the vital information that you provide to your customers and constituents. Groups of knowledge workers can use IM's collaborative tools to find, edit, review, reuse, and assemble information managed in a secure IM database. IM manages a wide variety of information, from files produced by popular desktop applications to highly modular document objects defined by XML and SGML."

LivePage Enterprise

Developer: Janna Systems
URL: http://www.janna.com/lpweb/lp_ent.htm

From the Web site:

"... delivers the power to build, manage and publish large, business-critical web sites and documents. It opens up the enterprise intranet as a direct document publishing medium for a broad set of authors using existing tools and skills. LivePage Enterprise is an integrated XML/SGML/HTML content-base management system (CBMS) which runs on industry standard SQL database engines. At the heart of LivePage Enterprise is the LivePage ContentServer, which uses the Content Relational storage model for high-performance storage of tagged data using SQL database servers."

Note: Siebel Systems (http://www.siebel.com) bought Janna systems in Q4 2000. The above link no longer works and it is not clear if LivePage Enterprise is still available.

POET Content Management Suite

Developer: Sorman, POET
URL: http://www.sorman.se/products/cms/index.asp,
http://www.poet.com/products/cms/cms.html

From the Web site:

"...provides XML and SGML publishers with component-level content management for streamlined content creation and production. CMS' advanced collaboration, reuse, versioning, and integration capabilities benefit publishers through more productive collaboration, better reuse of effort, and shorter creation cycles. CMS is flexible enough to accommodate multiple DTDs, data types, applications, custom interfaces, legacy systems, and best-of-breed tools-as part of a streamlined XML / SGML publishing solution."

In October, 2000, Sorman Information AB bought POET Content Management Suite. It holds the intellectual property rights for CMS worldwide, except in the US, Canada, and South Korea, and has a six-month option to buy the rights in the US and Canada.

Prowler

Developer: infozone
URL: http://www.infozone-group.org/projects_main.html (click on Prowler)
Database type: Object-oriented

Not yet reviewed.

SigmaLink

Developer: STEP Electronic Publishing Solutions GmbH
URL: http://www.step.de/sigmalink.htm

From the Web site:

"SigmaLink is an intranet-based document handling and editing system with full support for SGML and XML. Some of the advantages of SigmaLink are:
o Designed for publishers and their special needs.
o Handles both [XML] and [non-XML] documents and therefore supports migration to [XML] over the long term.
o Built of standard components, such as an SQL database system for full-text search, workflow, known SGML editors, etc.
o Offers both online and offline work modes, making it possible to use the system in, for example, home offices."

[Ed.-Any errors in translation are mine.]

Target 2000

Developer: Progressive Information Technologies
URL: http://www.target2000.com/main.html

From the Web site:

"This relational database publishing system uses SGML tagging and object-oriented concepts to prepare content for the infinite future possibilities of publishing. ... TARGET 2000 provides a simultaneous view of the same content across multiple products. Some of the system's other engaging features include:

o Completing one edition while working on a new edition.
o Facilitating creation of CD-ROM and Internet products.
o Keeping track of text, graphic, and multimedia content, stored within the database or referenced as external files.
o Letting you drag and drop content from one product to another.
o Providing fully tagged SGML, XML, HTML, or other output."

WSDOM XML-Portal

Developer: Radian Systems
URL: http://www.radsys.com/products/portal.htm

WARNING: This product might no longer be available. While a server for www.radsys.com is registered, it no longer seems to respond.

From the Web site:

"...an information hub and repository. It is a content management system that focuses on storage, data management, transfer, and access to documents and information generated by disparate applications. WSDOM XML-Portal is a single application that provides functionality for storage and retrieval, workflow, document management, and Enterprise Report Management (ERM). Because of the thin-client approach, using a Web browser as the user interface, your system can be deployed as a departmental, enterprise, or global application, using the infrastructure provided by the Internet or an Intranet.

"WSDOM XML-Portal aids the process by creating XML indexes for data, and organizing them to allow full text XML-tagged searching and presenting results via XSL (eXtensible Style Language) style sheets. It also works closely with WSDOM XML-Xpress, Radian Systems' "funnel" application that can interface with any database product or legacy application, and transform the data into XML objects."

XMLBase

Developer: eidon
URL: http://www.eidon-products.com/sgmlxmlbase.htm

From the Web site:

"SGMLbase/XMLbase enable document management with a precision and efficiency unknown so far. SGMLbase/XMLbase provide you with unrestricted access to all contents and markup contained in your SGML and XML documents. SGMLbase/XMLbase will store your documents in a relational database. To access them you can use the Xript high-level script language, the Xbase API programming interface, and the SQL standard database query language."

2.7 Persistent DOM Implementations

This category has now been merged with Native XML Databases.

2.8 XML Query Engines

XML Query Engines are standalone programs that can query XML documents. Currently, these implement a variety of languages: XQL, XPath, XML-QL, Quilt, XQuery, etc. In the future, I expect most to standardize on the W3C query languages: XPath and XQuery.

The line between XML Query Engines and Native XML Databases is somewhat blurry, as Native XML Databases invariably support an XML query language. In general, XML Query Engines appear to support querying and nothing else, while Native XML Databases offer more database functionality: their own data store, transaction support, APIs, etc.

I have not had time to track XML query languages and their implementations. Fortunately, Avi Rappaport maintains an excellent list of XML query languages and other XML query resources. You can find it at:

   http://www.searchtools.com/info/xml-resources.html

3.0 Additional Links

The following are links to sites listing XML software, including software for using XML with databases:

   Free XML Software (Lars Garshol)
   XML Resource Guide (XML.com)
   XML Software (James Tauber)
   Top: Computers: Data Formats: Markup Languages: XML: Tools: Databases (Open Directory Project)

For an ongoing discussion of the issues surrounding XML and databases (native, relational, object-oriented, etc.), join the XML:DB mailing list.

4.0 Comments and Feedback

Please send comments and feedback to Ronald Bourret at rpbourret@rpbourret.com. Please note that I travel often and it may take two to three weeks for me to reply.


Back to Ron Bourret's home page