XML Database Products:

Web Application Servers

Copyright 2000-2008 by Ronald Bourret


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


Web Application Servers build dynamic Web pages for delivery by a Web Server, such as the Apache Web Server. Most Web application servers have a scripting language that describes how a Web page is to be built. Scripting commands are frequently embedded in a text document called a "template", which contains literal text (to be included in the final Web page) and scripting commands (which describe how to build the rest of the Web page). For example, a template might look like the following, where <SelectStmt> and <Loop> are scripting tags that tell the Web application server to execute a SELECT statement and a loop:

   <title>Flight information</title>
   <p>The following flights are available:</p>
   <SelectStmt>SELECT Airline, FltNumber, Depart, Arrive FROM Flights</SelectStmt>
   <p>We hope one of these meets your needs.</p>

Because templates are simply text documents, they can be used to create any kind of text document, not just an HTML document. For example, they can be used to create a CSV (comma-separated values) document or an XML document, as is shown below:

      <Introduction>The following flights are available:</Introduction>
      <SelectStmt>SELECT Airline, FltNumber,
                  Depart, Arrive FROM Flights</SelectStmt>
      <Conclusion>We hope one of these meets your needs.</Conclusion>

Web application servers often contain complete application development environments and may provide access to data in a variety of data stores, including legacy databases, email messages, and application data.

There are a large number of Web application servers and the following list is certainly incomplete. For more products, see Cetus Links or the Open Directory Project.


Developer: Apache Software Foundation
URL: http://axkit.org/
License: Open Source
Database type: Relational (DBI)
Entry last updated: November, 2000

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.)
Developer: Apache Software Foundation
URL: http://cocoon.apache.org/
License: Open Source
Database type: Relational (JDBC), Native XML databases, LDAP, flat files, etc.
Entry last updated: February, 2002

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 (ESQL) for retrieving data from relational databases with JDBC. The tags largely mirror the most commonly used methods in JDBC, such as tags to prepare and execute queries, iterate through rows in a result set, and get column values from a result set. (Note that any SQL statement can be executed, not just a SELECT statement.)

If the statement is a SELECT statement, individual tags can be used to specify where column values are to be placed in the output document. In the case of joins, a "watch" column can be specified so that the corresponding tag is only created when the column value changes. This allows you to create nested XML in the expected way.
Developer: Adobe
URL: http://www.adobe.com/products/coldfusion/
License: Commercial
Database type: Relational (ODBC, OLE DB, Native drivers)
Entry last updated: December, 2008

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 uses templates, which are text documents that contain Cold Fusion Markup Language (CFML) tags. ColdFusion processes CFML tags -- such as by retrieving data from a database or repeating a loop -- and leaves other text unchanged. Thus, an XML document containing CFML tags could use ColdFusion to create additional XML. For example, it could retrieve data from a database and format it as XML.

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

CFML also contains tags for manipulating XML documents, such as creating or parsing XML documents, transforming XML documents with XSLT, or searching XML documents with XPath.
Developer: enhydra.org
URL: http://www.enhydra.org
License: Open Source
Database type: Relational (JDBC)
Entry last updated: November, 2000

Enhydra is a 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.
Developer: LassoSoft
URL: http://www.lassosoft.com/Products/index.lasso
License: Commercial
Database type: Relational (ODBC, JDBC, native drivers), FileMaker, LDAP
Entry last updated: December, 2008

Lasso is a Web application server designed for building database-driven Web sites. Lasso uses templates, which are text documents that contain Lasso tags. Lasso processes these tags -- such as by retrieving data from a database or repeating a loop -- to create Web pages. XML stored in a variable can be served in place of the page being processed. For example, a Web page could retrieve data from a database, construct XML from it, and serve it to the user.

Lasso also includes support for working with XML, including parsing, validating, searching (with XPath), and transforming (with XSLT) XML. Lasso scripts can also navigate XML using a DOM-like processing model.

Lasso includes GUI-based editor and also has plug-ins for other editors, such as Dreamweaver, Eclipse, and GoLive.
Pi.gia.ma Power
Developer: PGM Technology
URL: http://www.pgmtech.it/eng/ (in English)
http://www.pgmtech.it/index.php?page=1100 (in Italian)
License: Commercial
Database type: Relational (MySQL)
Entry last updated: May, 2005

Pi.gia.ma Power is a Web content management system "based on MySQL, PHP, XML, and XSL." It is designed for creating and managing Web sites. Using a GUI tool, users build Web pages from system objects (menus, search requests and results, forms, and so on) and user-defined objects (text, graphics, PDF files, and so on). The tool generates the appropriate XML for each object, which it then stores in the database in a number of pre-defined tables. Users can associate XSLT stylesheets with individual objects. In addition, HTML objects can be associated with CSS stylesheets.

Pi.gia.ma Power comes with a number of utilities, including Web-based administration tools; XSLT, CSS, form, object, and layout editors; and a backup utility. Other features include full-text search of both objects and system-maintained metadata, workflow, versioning, SOAP support, and automatic classification of content according to user-defined taxonomies. Performance features include caching, shared memory, and data compression. Security can be based on either user name and password or IP address.
Developer: Apple Computer
URL: http://developer.apple.com/tools/webobjects/
License: Commercial
Database type: Relational (JDBC)
Entry last updated: February, 2002

WebObjects is a Web application server. An application consists of one or more "components". Each component consists of a template (usually an HTML page, but this can presumably also be an XML document), an associated Java class, and a file that binds WebObjects-specific tags in the template to methods or variables in the class.

When a component is processed, the WebObjects engine processes any WebObjects-specific tags in the component's template and replaces them with their result, such as a dynamically generated form. A special tag can be used to link one component to another. In this case, the child component is processed and tag in the parent template replaced by the (processed) child template. For example, the child component might return the current time or the result of a database query serialized as XML. This allows applications to be built from a set of reusable components.

Database access is performed through "enterprise objects". These are roughly equivalent to Enterprise Java Beans (EJBs) and are used to encode business logic. Like EJBs, they are bound to tables and columns in the database -- the set of possible bindings is quite flexible. Like an EJB container, WebObjects handles database access, transactions, referential integrity enforcement, etc. Components that need to access the database use enterprise objects as their Java class.

Data retrieved from the database can be used to create XML documents in two ways. First, the data can be accessed directly from the enterprise object and placed in an XML template (assuming it is possible to have XML templates). Second, the enterprise object can be serialized as XML. A default serialization can be used or the user can use a special language that specifies how the object is mapped to XML.

Similarly, enterprise objects can be created from XML documents and then used to update the database. How an XML document is passed to an enterprise object is not clear, although presumably it could be passed as an HTTP parameter.
Developer: Zope Corporation
URL: http://www.zope.org/
License: Open Source
Database type: Object-oriented, Relational (ODBC), Non-relational (LDAP, IMAP)
Entry last updated: November, 2000

Zope is a 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.