XML Database Products:XML-Enabled DatabasesCopyright 2000-2007 by Ronald BourretOverviewXML-enabled databases contain extensions for transferring data between XML documents and their own data structures. They are used by data-centric applications, except when the database also supports native XML storage. (The difference between XML-enabled and native storage is that XML-enabled storage uses schema-specific structures that must be mapped to the XML document at design time. Native XML storage uses generic structures that can contain any XML document. For more information, see the overview in XML Database Products: Native XML Databases.) 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 Servers: XML-aware J2EE servers, Web application servers, integration engines, and custom servers.
Products
Access 2002
Developer: Microsoft
URL: http://msdn.microsoft.com/library/en-us/dnacc2k2/html/odc_acxmllnk.asp
License: Commercial
Database type: Relational
Entry last updated: February, 2002
Access transfers data to/from XML documents using a table-based mapping. Individual data values must be in child elements (attributes are ignored) and table/column names must match element names. In addition, Access can create an XML Schema document describing exported data.
Cache
Developer: InterSystems Corp.
URL: http://www.intersystems.com/cache/technology/components/xml/index.html
License: Commercial
Database type: Post-relational
Entry last updated: March, 2004
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.
Cache supports XML in three ways. First, it provides an implementation of XML data binding, which uses the object-oriented view of the data. This contains tools for creating DTDs and XML Schemas from classes stored in Cache and for creating classes from XML Schemas. Data can then be transferred between XML documents and objects stored in the database. Second, methods on any class stored in Cache can be exposed as Web services. Third, Cache's Web application server (Cache Server Pages) can use the data binding functionality of Cache classes to expose data as XML over the Web.
DB2
Developer: IBM
URL: http://www-306.ibm.com/software/data/db2/
http://www-306.ibm.com/software/data/db2/extenders/text/
http://www-128.ibm.com/developerworks/db2/zones/webservices/worf/
http://www-306.ibm.com/software/data/db2/extenders/xmlext/
License: Commercial
Database type: Relational, native XML
Entry last updated: March, 2007
DB2 version 9 supports XML in the base DB2 product, in the Net Search Extender, and in its Web Services Object Runtime Framework for DB2 (DB2 WORF). In addition, DB2 Express-C is a free version of DB2 that includes full XML support.
XML support in DB2 itself (known as pureXML) consists of native XML storage, XQuery, the publishing functions in SQL/XML (XMLELEMENT, XMLATTRIBUTE, XMLFOREST, XMLAGG, etc.), various other SQL/XML functions (XMLVALIDATE, XMLQUERY, XMLEXISTS, XMLCAST, etc.), and a decomposition engine. Native XML storage is used to store columns whose type is XML and is implemented through a proprietary, hierarchical storage mechanism. XML values are indexed by identifying the nodes to be indexed (using a subset of XPath) and specifying whether they are to be indexed as strings, numeric values, dates, or timestamps.
XML values can be queried with XQuery, which can be used as a standalone query language or called from SQL statements with the SQL/XML XMLQUERY function. XML values can also be used as a source of tabular data for SQL statements via the SQL/XML XMLTABLE function. Relational values can be queried with XQuery by first constructing an XML view of the data with the SQL/XML publishing functions, then querying the view with XQuery. Node-level updates are supported through a stored procedure that uses a path expression to identify the nodes to be updated and an XML value (element, attribute, etc.) to specify the new value.
The decomposition engine in DB2 is used to extract values from an XML document and store them in columns in relational tables. Values are transferred according to mappings defined by annotations in XML Schema documents. These annotations support object-relational mappings, with some additional capabilities, such as mapping multiple elements or attributes to the same table/column or mapping a single element or attribute to more than one table/column. Additional features include support for user-defined functions to modify values before insertion and conditional expressions to insert rows only if their values meet certain criteria.
Other XML support in DB2 includes a repository for managing XML Schemas to be used for validation and document decomposition, use of DTDs for resolving external entities and retrieving default values (but not for validation), and access to XML values through a variety of APIs, including JDBC 4.0, SQLJ, .NET, CLI, embedded SQL, and PHP.
The DB2 Net Search Extender contains a variety of search technologies, such as fuzzy searches, synonym searches, and searches by sentence or paragraph. It can be used when an XML document is stored in a single column and is XML-aware to the extent that searches can be limited to specific sections of XML documents, identified by their paths.
DB2 WORF allows users to define Web services through DADX documents. DADX documents extend the functionality of DAD documents (as used in the XML Extender -- see below) and describe how a Web service accesses data in the database. Supported functionality includes storing and retrieving documents with the XML Extender, executing SQL queries, and calling stored procedures. DB2 WORF can also generate WSDL documents from DADX documents.
Earlier versions of DB2 support the SQL/XML publishing functions and the XML Extender. The XML Extender can store XML documents in a single column as character data, extracting values into "side tables", which can then be queried with SQL statements. It can also decompose documents using a proprietary, XML-based mapping language called DAD (Data Access Definition). DAD supports object-relational mappings for transferring data to and from the database and a template-based language with embedded SELECT statements for transferring data from the database to XML. The XML Extender also supports MQSeries, validation, and XSLT.
eXtremeDB
Developer: McObject LLC
URL: http://www.mcobject.com/standardedition.shtml
License: Commercial
Database type: Object-oriented
Entry last updated: June, 2005
eXtremeDB is an object-oriented in-memory database. It supports a standard navigational API, as well as being able being able to generate an application-specific API from a database schema. An SQL implementation is available as an add-on. eXtremeDB is available in three versions: a standard version (which is available for conventional or shared memory), a single-threaded version, and a high-availability version. Transaction logging is available as an add-on.
eXtremeDB supports XML through XML data binding. From a database schema, it can generate methods to create new objects from XML documents, serialize existing objects as XML documents, and update existing objects from XML documents. In addition, it can generate XML Schema documents for the generated XML documents. The mapping from objects to an XML Schema was "developed in accordance with the W3C SOAP encoding recommendations" so that serialized objects can be used inside SOAP messages.
FileMaker
Developer: FileMaker
URL: http://www.filemaker.com/xml/overview.html
License: Commercial
Database type: FileMaker
Entry last updated: February, 2002
FileMaker allows users to return the results of a query as XML. Results are returned in one of two styles. The first style uses field names as element names, although the results of repeating and portal fields are wrapped in <DATA> tags. (A portal field appears(?) to link to another data record, like a foreign key in a relational database.) The second style is more generic, returning first a set of metadata, then the data wrapped in <ROW>, <COL>, and <DATA> tags. The metadata can then be used to transform the actual data. In addition, the query can specify the stylesheet to be used; a processing instruction referencing this stylesheet is placed in the returned document.
FileMaker can also accept requests to insert, update, or delete records, where the data is embedded in an XML document.
All XML requests are passed to FileMaker through CGI.
FoxPro
Developer: Microsoft
URL: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/fox7help/html/lngrfxmlfunctions.asp
License: Commercial
Database type: Relational
Entry last updated: April, 2002
Visual FoxPro has three methods for transferring data between an XML document and a FoxPro table: CURSORTOXML, XMLTOCURSOR, and XMLUPDATEGRAM. CURSORTOXML and XMLTOCURSOR transfer data between a FoxPro cursor or table and an XML document using a table-based mapping. Column data can be represented either as attributes or as child elements. If an XML Schema is present, FoxPro determines the mapping from the schema. Otherwise, it makes two passes through the XML document -- one to determine the structure of the document and construct the mapping, and one to transfer the data. When transferring data from the database to XML, FoxPro can generate an inline schema describing the data.
XMLUPDATEGRAM generates an XML updategram from tables and cursors in the current session that have buffered changes. The updategram represents the before and after conditions of the table or cursor and can be used to propagate changes, such as to COM controls or other products (like SQL Server) that understand updategrams.
Informix
Developer: Informix (now owned by IBM)
URL: http://www.informix.com/idn-secure/webtools/ot/, http://www-4.ibm.com/software/data/informix/blades/web/
License: Commercial
Database type: Relational
Entry last updated: November, 2000
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.
Matisse
Developer: Matisse Software
URL: http://www.matisse.com/product_information/
License: Commercial
Database type: Object-oriented
Entry last updated: August, 2003
Matisse is an object-oriented database that has three different APIs. First is native object support, which is available in a number of languages, including C++, Java, C#, Eiffel, PERL, Python and PHP. Second is an implementation of SQL 99, including support for stored procedures and triggers. This is available through JDBC and ODBC. Of interest, this can be used to enforce the referential integrity of objects. The third interface is XML.
XML is supported through XML data binding, in which XML documents are mapped to objects. The mapping is done by a utility that generates class schema from a DTD. Data can then be transferred between XML documents and objects in the database according to this mapping, and data loaded into objects is validated against the object schema. Matisse also provides "an object API to manipulate XML documents", although it is not clear if this is the DOM.
Matisse supports transactions and uses versioning instead of logs as a way to improve update speed. (Versions are also directly available to the user, so historical queries can be performed.) Other features include support for .NET and J2EE, a database adminstration API, "fast joins" through "pre-computed relationships", multi-threading, and client- and server-side caching.
[Ed. -- August, 2003. According to an April, 2003, press release, Matisse uses jAllora to transfer data between XML documents and Matisse. It is not clear if this is in addition to or replaces the features described above.]
Objectivity/DB
Developer: Objectivity
URL: http://www.objectivity.com/DevCentral/Products/TechDocs/Datasheets/ObjyXML.html
License: Commercial
Database type: Object-oriented
Entry last updated: February, 2002
From the Web site:
"The Objectivity XML Interface Tool supports export of objects from the latest version of Objectivity/DB (Release 6) in XML format and import of XML formatted data into Objectivity DB. Objectivity will provide open source for the XML Interface Tool free of charge to its customer base."
OpenInsight
Developer: Revelation Software
URL: http://www.revelation.com/website/vipweb.nsf/
e4a32622500660198525631900091149/178609577b262b2a852563f500770fc5?OpenDocument
License: Commercial
Database type: Multi-valued
Entry last updated: January, 2003
OpenInsight is a development environment that can access data in its own "native tables", as well as Oracle, Lotus Notes, and ODBC and OLE/DB databases. The native tables, which are the same as those used by the DOS-based Advanced Revelation development environment, are a multi-valued database. It appears that XML support is limited to data stored in the native tables.
The mapping between XML documents and native tables tables appears to be table-based, in which a single document can contain multiple rows from the same table. Because columns in the native tables can be multi-valued, child elements in the XML document can occur multiple times. It also appears that only child elements (and not attributes) are supported. Users can map XML documents to the database in one of two ways. Either they can map individual child elements to individual columns, or they can map the entire document to a single column and map child elements to calculated columns.
OpenInsight can retrieve data from the database in three ways. First, it can execute a query and return the data as XML. Second, it can execute XPath queries against the database, presumably viewing the database as a set of virtual XML documents defined by a particular mapping. Third, it can retrieve data from specific columns in a particular row according to the element types to which those columns have been mapped.
An XML Schema is required to store data from an XML document in the database. (DTDs are not supported.) OpenInsight can generate an XML Schema for a given table.
OpenInsight includes GUI-based tools for importing XML documents into native tables, retrieving the result of queries as XML, viewing data stored in the database as XML, and executing XPath queries against the database.
Oracle
Developer: Oracle
URL: http://www.oracle.com/technology/tech/xml/xmldb/index.html
http://www.oracle.com/technology/products/database/application_development/sqlxml/index.html
http://www.oracle.com/technology/tech/xml/xquery/index.html
License: Commercial
Database type: Relational, native XML
Entry last updated: November, 2005
Oracle provides support for an XML data type, SQL/XML, XQuery, XSLT, the DOM, XML indexes, the XML DB Repository, and XML Schemas.
XML support starts with the XMLType data type, which implements the XML data type defined by SQL/XML. Data in XMLType columns can be stored in one of two ways: with object-relational storage or as a CLOB. Application code is the same regardless of which option is chosen, although changing from one storage type to the other requires a database export and import. In addition, there are a number of significant differences between the storage mechanisms. For example:
- CLOB storage round trips documents exactly, while object-relational storage round trips documents at the level of the DOM.
- CLOB storage can store any document, while object-relational storage can only store documents that conform to a particular XML Schema.
- Object-relational storage can often perform node-level updates, while CLOB storage always performs document-level updates.
- CLOB storage has fewer indexing options and may be significantly slower to query than object-relational storage.
Object-relational storage is defined with an annotated XML Schema. Annotations can be made by the user or generated automatically. Annotating schemas by hand generally results in more efficient mappings and also allows users to create XML "views" over existing relational data. In either case, when the schema is registered with the database, the database automatically creates any tables and columns needed to store documents conforming to the schema. Unlike most software that uses an object-relational mapping to store XML in relational tables, Oracle can round-trip XML documents at the level of the DOM. To do this, it uses hidden columns to store information that is not directly modeled by SQL, such as sibling order, processing instructions, and comments.
XMLType columns can be constrained to a particular XML Schema. In addition to limiting the documents that can be stored in the column to those that conform to the schema, this allows the query engine to optimize queries based on the information in the schema. However, because constraints are limited to a single schema, updating that schema means that all existing data must be migrated to the new schema.
XMLType columns can be indexed in one of four ways. First, when object-relational storage is used, the columns to which the XML elements and attributes are mapped can be indexed using convential B-tree indexes. Second, XMLIndex indexes can be constructed over any XML values, regardless of how they are stored. These index paths, values, and order information. Function-based indexes can also be used over any XML values. These use proprietary functions such as extractValue (see below) to identify values in the XML document to be indexed and are (apparently) evaluated by matching XPath expressions in queries to those used to define the index. Finally, Oracle Text indexes provide full-text indexing of the values in elements and attributes.
XML values can be queried with XQuery, which is called from SQL statements with the proposed SQL/XML XMLQUERY function. They can also be queried with the proprietary existsNode and extract functions in SQL, which accept an XPath expression and, respectively, test the existence of a node or return a set of nodes. XML values can be used as a source of tabular data for SQL statements via the proposed SQL/XML XMLTABLE function and the proprietary extractValue function in SQL, which returns a value identified by an XPath expression. Updates are performed via proprietary SQL functions for inserting, appending, and deleting nodes as well as updating node values. These identify nodes by XPath expressions. Oracle also defines an ora:contains function in XQuery for performing full-text searches over values in XML documents. This uses Oracle Text indexes if they are available.
Relational values can be used to construct XML values via the SQL/XML publishing functions (XMLELEMENT, XMLATTRIBUTE, XMLFOREST, XMLAGG, etc.) They can also be queried with XQuery by first constructing an XML view of the data, then querying the view with XQuery. Views can be constructed with the SQL/XML publishing functions, an annotated XML Schema, or the proprietary ora:view function in XQuery, which (apparently) uses the table-based mapping defined by SQL/XML to map a table to a virtual XML document.
Oracle includes two implementations of XQuery: a mid-tier implementation and an implementation that is part of the database engine. The mid-tier implementation is commonly used to query individual XML values, such as XML messages, while the engine implementation is optimized for querying values stored in the database. The engine implementation attempts to rewrite both XPath and XQuery expressions as SQL statements. This is possible only when the XML value is stored using object-relational storage or the expression can be resolved by querying an index. Otherwise, the query is evaluated directly; for XML values stored as CLOBs this can be "very expensive", as it involves parsing the XML and (apparently) building a DOM tree.
Oracle also features the XML DB Repository, which provides a file-system like view over objects in the database. (Although designed specifically for accessing XML values, the XML DB Repository can be used to access any object stored in the database.) Objects are assigned a path and corresponding URL and can be accessed via HTTP, WebDAV, and FTP, as well as JDBC, PL/SQL, OCI, and ODP.NET. (SQL-based access uses the exists_path and under_path operators to query the RESOURCE_VIEW and PATH_VIEW views of the tables describing the repository.) In addition, the repository maintains system-defined metadata for each object (owner, creation date, etc.) and optional user-defined metadata in the form of an XML document, as well as providing versioning, access control lists, and hierarchical indexes for optimizing repository access.
The support described above is for Oracle 10g release 2. The major XML features in Oracle 10g release 2 are XQuery support and XMLIndex indexes. Most of the other features have been supported since Oracle 9i release 2. Oracle 8i and Oracle 9i release 1 support the XML SQL Utility for Java, the Internet File System (iFS) (which provides functionality similar to the XML Repository), and searching XML documents stored as CLOBs with Oracle Intermedia XML Search. In addition, Oracle 9i release 1 supports the XMLType data type (which is stored as a CLOB) and XPath searches over XMLType columns.
PostgreSQL
Developer: PostgreSQL Global Development Group
URL: http://developer.postgresql.org/cvsweb.cgi/pgsql/contrib/xml2/README.xml2?rev=1.7
http://www.throwingbeans.org/postgresql_and_xml.html
License: Open Source
Database type: Relational
Entry last updated: December, 2006
PostgreSQL provides functions for executing for XPath queries and XSLT processing over XML values, as well as checking if an XML value is well-formed. XML values can be values stored in character (CHAR, VARCHAR, CLOB, etc.) columns or passed as character input values.
There are a number of XPath functions. The xpath_string, xpath_bool, and xpath_number functions execute an XPath query and return the result as a string, boolean, or floating point number. These can be used, for example, in a select list or a WHERE clause. The xpath_nodeset function executes an XPath query and returns the value as a string; it optionally accepts the name of a root element and an element to wrap each value in the node set returned by the query. The xpath_list function is similar, except that it returns values separated by a user-specified separator, such as a comma. Finally, the xpath_table function accepts the name of a table, column, and key column, as well as a list of XPath queries and criteria to be used in a WHERE clause. It returns a table (specified in an AS clause) that uses the primary key and has one column for each XPath query; this can be used in the FROM clause of another query.
There is a single XSLT function, xslt_process, which accepts an XML value (or the URL of an XML document), an XSLT stylesheet (or the URL of an XSLT stylesheet), and an optional set of parameters. It returns the result of applying the stylesheet to the XML value.
In addition to the functions described above, Pavel Stehule has written a patch supporting the SQL/XML publishing functions (XMLELEMENT, XMLFOREST, etc.). It is based on the CString type and "hasn't high quality, but can be useful for testing functionality."
SQL Server
Developer: Microsoft
URL: http://www.microsoft.com/sql/default.mspx
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnsql90/html/sql2k5xml.asp
License: Commercial
Database type: Relational
Entry last updated: November, 2000
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.
Sybase ASE 12.5
Developer: Sybase
URL: http://my.sybase.com/content/1013051/3929XMLwpaperv9.pdf
http://manuals.sybase.com:80/onlinebooks/group-as/asg1250e/jcs_kona/@Generic__BookTextView/12930
License: Commercial
Database type: Relational
Entry last updated: July, 2002
Sybase supports XML in two ways. First, the ResultSetXml class can transfer data between an XML document and the database. A ResultSetXml object can be created from an XML document or a SELECT statement. Among other things, applications can modify the data in a ResultSetXml object, serialize the data to an XML document, or create an SQL script to create a table for the data and store the data in the database. The XML document used by ResultSetXml has a proprietary format that contains a set of ColumnMetaData elements followed by a set of Row and Column elements.
Sybase also has native XML capabilities. It can store XML documents in a pre-parsed, indexed form in BLOB columns. These can then be queried with XQL. (The XQL engine can also be used to query XML documents stored elsewhere, such as in the file system or on the Web.) Updates must be performed at the level of whole documents.
UniData
Developer: IBM
URL: http://www-306.ibm.com/software/data/u2/unidata/
License: Commercial
Database type: Nested relational
Entry last updated: April, 2004
UniData is a nested relational database, which is a relational database that does not follow first normal form. That is, it allows columns to have multiple values for a single row. Multi-valued columns may be grouped together into "associations", which are effectively nested tables. There are two different types of multi-valued columns -- multi-valued and multi-subvalued -- and these types determine the degree of nesting in an association. The multi-valued columns in an association effectively form a sub-table, while the multi-subvalued columns in an association effectively form a sub-sub-table; deeper nesting is not supported. Note that a table may contain multiple associations and that multi-valued columns are not required to be in an association.
When retrieving data from the database, UniData uses what is effectively a table-based mapping, although this is modified to handle the nested tables that can occur in UniData tables. As in a table-based mapping, one element is created in the XML document for each row in the table. Because UniData tables can effectively contain sub-tables and sub-sub-tables, child and grandchild elements are created for each sub-table "row" and sub-sub-table "row" as needed.
There are three options for mapping data to an XML document. In an attribute-centric mapping (the default), data from single-valued columns is stored as an attribute of the row element, data from multi-valued columns is stored as an attribute of the association (sub-table) element, and data from multi-subvalued columns is stored as an attribute of the sub-sub-table element. The element-centric mapping is the same as the attribute-centric mapping except that data is stored in child elements instead of attributes. In both the attribute- and element-centric mappings, UniData generates element and attribute names from table, association, and column names. The last mapping option is "mixed" mapping, in which the user specifies whether to map columns to attributes or elements using an XML-based mapping language. Users can also specify element and attribute names (including namespace name), as well as how data is to be converted and formatted before it is placed in the XML document.
Applications specify that they want data returned as XML with a TOXML clause on the LIST command in UniQuery or the SELECT statement in UniData SQL. This clause allows users to specify whether they want to use an attribute-centric, element-centric, or mixed mapping, as well as whether to include a DTD in the resulting XML document. If a SELECT statement retrieves data from multiple tables, UniData nests data according to a hierarchy defined by the order of columns in the select list. In particular, if a column in the select list comes from a different table than the previous column in the list, UniData creates a new child element for that column's table. Thus, if columns are grouped by table in the select list, data is nested in the XML document by table and the nesting hierarchy is defined by the order in which the tables occur. If columns are not grouped by table, nesting still occurs, but is unlikely to give the desired result.
UniData can also treat an XML document as a source of data. The user specifies how this is done with a different XML-based mapping language. The user uses an XPath expression to specify the start node in the XML document; this node corresponds to a row of data. The user then uses relative XPath expressions to map descendant elements and attributes to columns in the row. Normal XPath syntax is used to map an element or attribute to a single-valued column, while a modified XPath syntax is used to map a set of elements or attributes to multi-valued or multi-subvalued columns.
Applications use the mapping file in UniBASIC, LIST commands, and SELECT statements. In each case, they specify the name of the mapping file and the XML file and UniData returns the data as if it were rows of data retrieved from a UniData table.
UniVerse
Developer: IBM
URL: http://www-306.ibm.com/software/data/u2/universe/
License: Commercial
Database type: Nested relational
Entry last updated: April, 2004
UniVerse is a nested relational database, which is a relational database that does not follow first normal form. That is, it allows columns to have multiple values for a single row. Multi-valued columns may be grouped together into "associations", which are effectively nested tables. There are two different types of multi-valued columns -- multi-valued and multi-subvalued -- and these types determine the degree of nesting in an association. The multi-valued columns in an association effectively form a sub-table, while the multi-subvalued columns in an association effectively form a sub-sub-table; deeper nesting is not supported. Note that a table may contain multiple associations and that multi-valued columns are not required to be in an association.
When retrieving data from the database, UniVerse uses what is effectively a table-based mapping, although this is modified to handle the nested tables that can occur in UniVerse tables. As in a table-based mapping, one element is created in the XML document for each row in the table. Because UniVerse tables can effectively contain sub-tables and sub-sub-tables, child and grandchild elements are created for each sub-table "row" and sub-sub-table "row" as needed.
There are three options for mapping data to an XML document. In an attribute-centric mapping (the default), data from single-valued columns is stored as an attribute of the row element, data from multi-valued columns is stored as an attribute of the association (sub-table) element, and data from multi-subvalued columns is stored as an attribute of the sub-sub-table element. The element-centric mapping is the same as the attribute-centric mapping except that data is stored in child elements instead of attributes. In both the attribute- and element-centric mappings, UniVerse generates element and attribute names from table, association, and column names. The last mapping option is "mixed" mapping, in which the user specifies whether to map columns to attributes or elements using an XML-based mapping language. Users can also specify element and attribute names (including namespace name), how data is to be converted and formatted before it is placed in the XML document, and whether to include the root and/or sub-table elements.
Applications specify that they want data returned as XML with a TOXML clause on the LIST command in RetrieVe or the SELECT statement in UniVerse SQL. This clause allows users to specify whether they want to use an attribute-centric, element-centric, or mixed mapping, as well as whether to include a DTD or XML Schema in the resulting XML document.
UniVerse also supports an XML-based object-relational mapping language. This allows multiple tables to be mapped to a single XML document, with primary key / foreign key relationships in the database determining the nesting structure in the document. The language handles single- and multi-valued columns in the same way as the language described above. That is, single-valued columns can be mapped to child elements or attributes of a row element, and multi-valued columns can be mapped to child elements or attributes of an association element.
Applications can use object-relational mapping documents with TCL and UniVerse BASIC. In TCL, there are commands to transfer the data for entire documents to/from the database. In BASIC, there are functions to transfer data from entire documents to/from the database, as well as the XMAP API, which gives applications row-by-row control over what data is transferred.
Versant enJin
Developer: Versant Corp.
URL: http://www.versant.com/products/enjin/datasheet.html
License: Commercial
Database type: Object-oriented
Entry last updated: November, 2000
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.
View500
Developer: eB2Bcom
URL: http://www.view500.com/view500.php
License: Commercial
Database type: Proprietary (LDAP)
Entry last updated: January, 2006
View500 is an LDAP directory based on a proprietary data store. It is XML-enabled through its support of the XED (XML Enabled Directory) specification, which is currently [Jan. 2006] an IETF draft standard. XED provides three primary features to support XML:
XED defines an XML version of the LDAP protocol (XLDAP). This includes an XML form of LDAP search filters, which are used to search LDAP directory data. XED defines an XML encoding for ASN.1 values, called the Robust XML Encoding Rules (RXER). This allows LDAP directory data to be expressed as XML and is what "XML-enables" LDAP directories. XED allows directory users to define data types for directory attributes (database fields) using DTDs, XML Schemas, or RELAX NG schemas as well as ASN.1. This means that directories that support XED provide native XML storage well as XML-enabled storage, where directory attributes function in roughly the same manner as native XML database collections. (The major difference is that native XML database collections can be restricted to zero, one, or (sometimes) multiple XML schemas, while XED directory attributes must be restricted to a single XML schema, although using an XML Schema that matches any XML document replicates restriction to zero schemas.)
In addition to XED, View500 supports a number of X.500, ASN.1, and LDAP specifications. It also supports transactions, full-text searches, security, and distributed operation. It has C/C++, Perl, PHP, Java, JavaScript, and HTML APIs.
|
|