Ronald Bourret

Consulting, writing, and research in XML and databases

Member

XML Database Products:

XML Servers

Overview

XML servers are XML-aware J2EE servers, Web application servers, integration engines, and custom servers. Unlike middleware, XML servers usually run in a separate process space from the application. Some XML servers are used to build distributed applications, such as e-commerce and business-to-business applications, where XML serves as the data transport. Others are used simply to publish XML documents to the Web. XML 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.

Related categories

Middleware: Software you call from your application to transfer data between XML documents and databases.
IDEs and Editors: Software you use to write XML applications or edit XML documents.
XML-Enabled Databases: Databases with extensions for transferring data between XML documents and themselves.

Products

ATG Relationship Management Platform: Developer: ATG
URL: http://www.atg.com/en/products/atg62_overview.jhtml
License: Commercial
Database type: Relational (JDBC)
Entry last updated: March, 2004

ATG Relationship Management Platform is a development environment for building J2EE applications, which may be run on the ATG Dynamo J2EE application server as well as other J2EE application servers. The core product consists of an application development framework and various tools for building, personalizing, and analyzing Web sites. Add-on products include frameworks for building portals and e-commerce applications, as well as a content management system.

The application development framework includes a Java Bean registry, tag libraries, Servlet Beans (which are used to create dynamic XML or HTML content), a repository API, a JMS-based messaging system, a security API, and support for Web services. The repository API essentially treats data sources as a set of objects and uses its own query language, RQL, which is similar to the WHERE clause in SQL. ATG includes implementations of the repository API for relational databases, LDAP, and file systems, as well as an implementation that can combine data from multiple repositories. Web services support includes predefined Web services for accessing repositories, as well as tools for creating custom Web services.

ATG Relationship Management Platform supports XML in a number of ways:

o Java Server Pages (JSPs) can be used to construct XML documents. For example, these might retrieve data from a database using the repository API and construct an XML document from this data.

o ATG includes Java Beans for creating DOM trees from XML documents, searching DOM trees with XPath, and applying XSLT stylesheets to XML documents. These Beans are typically used in JSPs.

o ATG includes classes for transferring data between XML documents and repositories. The tools can construct XML documents from repository data, insert the data in an XML document into a repository, update repository data based on the data in an XML document, and delete repository data based on the data in an XML document. A proprietary XML language is used to map repository schemas to XML schemas.

o ATG includes command-line tools for generating XML Schemas from repository schemas.
AxKit: Developer: AxKit.com Ltd.
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.)
Cocoon: Developer: Apache Software Foundation
URL: http://xml.apache.org/cocoon/
http://xml.apache.org/cocoon/userdocs/xsp/esql.html
License: Open Source
Database type: Relational (JDBC)
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.
ColdFusion: Developer: Macromedia
URL: http://www.macromedia.com/software/coldfusion/
License: Commercial
Database type: Relational (ODBC, OLE DB, Native drivers)
Entry last updated: November, 2000

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.

ColdFusions uses templates, 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.
Enhydra: 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.
Enosys Integration Suite: Developer: Enosys Software
URL: http://www.enosyssoftware.com/products.html
License: Commercial
Database type: Relational (JDBC), XML, HTML, Web services, flat files
Entry last updated: January, 2003

The Enosys Integration Suite is a heterogeneous join engine that can join data from relational databases, XML documents, HTML documents, Web services (using SOAP), and flat files. (It may be possible to integrate data from other sources through custom translators, but this is not clear.) Each data source is wrapped by a translator, which provides an XML view of the data. Translators can return both metadata (in the form of an XML schema) and data (in the form of an XML document) about a particular data source.

The join engine uses XQuery as its query language. It decomposes queries into queries against individual data sources, then passes the query fragments via translators to those data sources for execution. The translators return the data as XML, which the join engine uses to build the query result. Query optimizations include "query pre-compilation, XML document caching, and results evaluation and pipelining".

XML document caching is used for data that is either static or slow to retrieve. The cache is built on a JDBC database and is optimized for Oracle 8i. Documents in the cache can be refreshed on demand or at regular intervals.

The Enosys Integration Suite comes with a set of GUI-based tools to build queries, applications, and Web services. The latter tool supports SOAP, WSDL, and UDDI. Also included are utilities for configuring authentication and access control on a per-view basis, controlling the cache, logging the activities of the join engine, and monitoring connections.
Interaction Server (formerly DataChannel Server): Developer: Netegrity
URL: http://www.netegrity.com/products/index.cfm?leveltwo=Interaction
License: Commercial
Database type: Relational (JDBC, ODBC)
Entry last updated: November, 2000

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

Interaction Server 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.
Lasso: Developer: Blue World Communications
URL: http://www.blueworld.com/blueworld/products/
License: Commercial
Database type: Relational (ODBC, native drivers)
Entry last updated: November, 2000

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.
Liquid Data: Developer: BEA
URL: http://www.bea.com/framework.jsp?CNT=overview.htm&FP=/content/products/liquid_data/
License: Commercial
Database type: Relational (JDBC), XML, Web services, CSV files, etc.
Entry last updated: August, 2003

Liquid Data is a heterogenous query engine that is part of the WebLogic Platform. (The WebLogic Platform is a family of products for writing J2EE applications. It includes a J2EE server, an integration engine, a portal builder, and a development environment.)

Liquid Data implements XQuery over a virtual data store, in which data from different sources is mapped to virtual XML documents. Queries are decomposed into queries against individual data sources; the query engine uses the results from these queries to build the final query result. Liquid Data optimizes queries and caches results in a user-configurable cache.

Liquid data supports a variety of sources, including relational databases (including stored procedures), XML documents, Web services, flat files, and application data. Relational data appears to be mapped using a table-based mapping. Liquid Data also supports parameterized views, which are defined in XQuery and may be used in other queries.

Liquid Data can be called from EJBs, JSPs (using the Liquid Data tag set), and from other components in the WebLogic family. In addition, it can generate a Web service to execute a particular XQuery query. Liquid Data comes with a GUI-based query builder and administration tools.
MatriXML: Developer: MojoTechnology, Inc.
URL: http://www.mymatrixml.com/
License: Commercial
Database type: Oracle. External relational through ODBC
Entry last updated: November, 2000

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.
Net.Data: Developer: IBM
URL: http://www-4.ibm.com/software/data/net.data/
License: Commercial
Database type: Relational (ODBC, JDBC, Native Drivers)
Entry last updated: November, 2000

A Web server add-on for transferring data from a database to XML (or any text-based format). The product uses templates with 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.
Nimble Integration Suite: Developer: Nimble Technology
URL: http://www.nimble.com/solutions/products/suiteoverview/
License: Commercial
Database type: Relational (ODBC), non-relational (IMS, SAP, Notes, flat files, etc.)
Entry last updated: February, 2002

The Nimble Integration Suite is a heterogeneous join engine bundled with related tools. It can join data from both relational and non-relational sources. This is done by first retrieving data from various data sources as XML documents, then executing XML queries against those documents using XML/QL. The result is returned as XML. The integration engine includes a cache with user-specified timeouts, so queries against back-end data are minimized.

Users map data sources to XML with XML Maps, and can define two further refinements. XML Views define logical XML documents based on other (possibly logical) XML documents, such as those defined by XML Maps, and Lenses are pre-defined (usually parameterized) queries that include information about how the results are to be formatted. XML Maps and XML Views are designed to be used internally by the integration engine, while Lenses are designed to be used by applications. It is not known how data in databases can be mapped to XML.

The Nimble Integration Suite supports a variety of security mechanisms (LDAP, Microsoft Active Directory Services, NT domains, Secure Socket Layer, RSA 128-bit encryption) and has COM and Java APIs, as well as ASP and JSP plug-ins. It includes tools for mapping data sources to XML, resolving conflicts in the ways different data sources represent the same information, and administration.
Noetix Web Query: Developer: Aris Software, Inc.
URL: http://www.noetix.com/prod_ente_webq_NoetixWebQuery.asp
License: Commercial
Database type: Relational (ODBC)
Entry last updated: November, 2000

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.
Orbeon Presentation Server: Developer: Orbeon.org
URL: http://www.orbeon.org/software/, http://www.orbeon.com/ois/doc/
License: Open Source
Database type: Relational (JDBC), Native XML (XML:DB, Tamino, Oracle 10g)
Entry last updated: September, 2004

From the company:

"The Orbeon Presentation Server is a J2EE-based MVC framework for building Web applications that present and capture XML. Data from multiple sources, including relational and native XML databases, Web services, LDAP servers, and files can be transformed into XML and then manipulated and validated before being presented in a Web page to an end-user. Information can be collected from users as XML data using HTML forms that are defined with standard W3C XForms. This XML data can then be processed using XML pipelines and sent to a back-end system like SQL database, Web service, etc. XML pipelines are defined using a proprietary pipeline definition language."

"Access to SQL databases is done by writing SQL statements in one or more XML configuration files that also describe a very simple XML-relational mapping. More complex transformations are done in XSLT. Access to native XML databases is also provided, specifically for eXist (via the XML:DB API), Oracle 10g (via a proprietary API), and Tamino (via a proprietary API)."
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.
PolarLake Database Integrator: Developer: PolarLake
URL: http://www.polarlake.com/products/databaseintegrator/
License: Commercial
Database type: Relational (JDBC)
Entry last updated: November, 2002

PolarLake Database Integrator is server software that processes both incoming and outgoing XML documents. XML documents are processed according to XML Circuits. An XML Circuit consists of selection rules, which use XPath to identify different parts of the document, and actions, which describe how each part is to be processed. A given part can be processed by multiple actions, which are performed in series.

Actions are performed by components, which can be Java classes, XSLT stylesheets, or BeanShell scripts. A number of components are included with the Database Integrator. These include database components for starting, committing, and rolling back transactions; inserting, updating, and deleting data; mapping XML to the database; and executing stored procedures. Transactions can be nested, and the XML/database mapping appears to be table-based. Because actions can execute Java classes and stored procedures, PolarLake Database Integrator can be used to implement a Web services interface to existing code.

The XML document fed to an XML Circuit can have a number of sources. It can come from HTTP, SMTP, FTP, JMS-based messaging systems, Microsoft Message Queue, and TIBCO Rendevous, as well as from the database itself. The latter source requires that query results be mapped to an XML document using one of the mapping components.

XML Circuits are implemented using SAX. When a SAX event matches a selection rule, that event is passed to the components which implement the corresponding actions. Because multiple XPath expressions might match a given event, the event might be processed by multiple components. And because events corresponding to sibling elements define non-overlapping subtrees, these events can be processed in parallel.

PolarLake Database Integrator includes a GUI-based tool for defining XML Circuits.
Rhythmyx Content Manager: Developer: Percussion Software
URL: http://www.percussion.com/rhythmyx/index.htm
License: Commercial
Database type: Relational, Lotus Notes
Entry last updated: November, 2000

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
License: Commercial
Database type: Relational (ODBC)
Entry last updated: November, 2000

A CGI application for serving database-driven HTML and XML documents. Data is retrieved through SQml Publisher, which uses templates. 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.
Total-e-Business (formerly Bluestone XML-Server): Developer: HP Bluestone
URL: http://h21022.www2.hp.com/HPISAPI.dll/hpmiddleware/products/Total-e-Server/default.jsp
License: Commercial
Entry last updated: July, 2001

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 data binding is used in Total-e-Business applications in two places. First, XML 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.

Second, XML can be used 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.
Visual Net Server: Developer: CNet
URL: http://www.cnet.se/visualnetservereng.vns
License: Commercial
Database type: Relational (ODBC, ADO, Microsoft SQL Server 2000)
Entry last updated: February, 2002

Visual Net Server is "an application server and integrated development environment for XML content publishing and syndication applications." A Visual Net Server application is a template that tells the server how to create an XML document with data from a variety of sources. The document can then be transformed using XSLT or built-in functions (including grouping, sums and aggregation, and value set translations) and output to a variety of formats.

Visual Net Server contains built-in converters for converting to/from Word, Quark, Excel, HTML, and text files. It supports database access (reading and writing) through ADO and ODBC, along with native support for SQL Server's XML functionality.

Visual Net Server includes support for SOAP, as well as validation of imported XML with XML Schemas.
WebObjects: Developer: Apple Computer
URL: http://www.apple.com/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.
XA-Suite: Developer: XAware, Inc.
URL: http://www.xaware.com/products
License: Commercial
Database type: Relational, native XML, mainframe, etc.
Entry last updated: July, 2002

XA-Suite is a suite of components that use XML to integrate data from "over 150 ... systems including RDBMS, XML DBMS, ERP Systems, CRM Systems, Main Frames, EJB Applications, CORBA Applications, Web Services layers, HTTP, FTP, EMAIL and other enterprise applications." The suite consists of five main components.

XA-Designer is a tool for defining bi-directional XML views, which are known as business documents, or BizDocs. BizDocs are made up of one or more business components, or BizComponents. Each BizComponent maps data from a particular data source to a part of the XML document. Thus, a given BizDoc can contain data from multiple data sources. BizComponents can be used in more than one BizDocs, which is useful because it means that data from a particular source needs to be mapped only once. In addition, data retrieved by one BizComponent can be used as a key to retrieve data with another BizComponent.

BizDocs are deployed to XA-iServer, which is the integration engine. XA-iServer integrates outbound data from multiple sources into a single document according to the rules in the BizDoc. It also decomposes inbound XML documents according to these rules and sends the data to the designated sources. It appears that XA-iServer supports two-phase commits, as "any failure causes the entire operation to be rolled back from all systems." In addition, users can define workflow using XML-based business rules. XA-iServer can be run on a J2EE server, a Web server, or with .NET.

Applications communicate to XA-Suite through XA-Connectors. These are available for SOAP, JMS, EJB, servlets, CORBA, HTTP, CGI, COM, and ISAPI, as well as Java and C++ APIs. In addition, a toolkit is available for building custom connectors.

XA-iServer connects to back end data sources through XA-Adaptors. XA-Adaptors are available for a large number of data sources, including relational databases (ODBC, JDBC, OLE DB), native XML databases (NeoCore XMS, Tamino, Ipedo), XML over FTP and HTTP, mainframe databases, various enterprise applications (SAP, PeopleSoft, JD Edwards), and so on. In addition, a toolkit is available for building custom adaptors.

The final component is XA-Manage, which is used to manage the system.
XML Portal Server (XPS): Developer: Uniway
URL: http://www.uniway.be/products/content_products_icommerce_sequoia.html
License: Commercial
Database type: Relational, Lotus Notes, etc.
Entry last updated: November, 2000

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.

Note: Sequoia Software may be out of business, leaving Uniway as the sole developer of XPS. Sequoia's Web site (http://www.sequoiasoftware.com) does not respond. (February, 2002)
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
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.