Maintenance release.
Accept collations like "fr" without leading slash. A leading slash was required so far.
Beware however that if a base-URI is defined through options or API, a relative collation URI can be resolved against this base URI.
Incremental backup: works in the same way as full backup, but only copies differences.
Interfaces in: Java API, XQuery extension functions, Server (manual and scheduled), user interface in QizxAdmin.
Concurrent updating: "document NNN not found" errors were appearing when several threads modified the same document without locking (which is BTW not a good practice).
Another internal issue fixed at the same time.
Check on a database check created by several threads: some collections were reported as not found, some queries could fail due to an index segment ordering issue.
Administration facilities for Qizx Server and for embedded XML databases:
These facilities are implemented at several levels:
XQuery extension functions:
functions prefixed by server: are callable through the REST API and can handle several XML Libraries.
Functions prefixed by admin: are callable in any context and handle the current Library.
Administrator tools:
Qizx Server: Web Applications (aka XQuery Server Pages):
A mechanism for writing web applications in XQuery:
Basically a page template is a stored XQuery generating (X)HTML elements. HTTP Request parameters are bound automatically to XQuery variables (with possible type conversion), then the result of evaluation is directly serialized as the HTTP response.
This mechanism comes with a library of XQuery extension functions to handle http parameters, headers, sessions, cookies etc
Qizx Server:
caching of Result Sequence in eval request. This allows iterating efficiently on a long sequence of results, without having to reevaluate an XQuery expression on each request.
Cache size can be defined in Server configuration.
The query compiler now recognizes a "range predicate" in the form
[@x >= 1 and @x <= 10]
and optimizes it as if the
x:in-range function was used (i.e [x:in-range(@x, 1, 10)]
).
Notice that this optimization is not possible in general on
child elements, because for example the meaning of [date >=
1999 and date <= 2011]
and [ x:in-range(date, 1999,
2011) ]
can be different if there are several child elements
date. Therefore it is recommended to use x:in-range() when
appropriate.
The predicate [ x:in-range(date, 1999,
2011) ]
is equivalent to: [some $adate in date satisfies
$adate >= 1999 and $adate <= 2011]
, but the latter form is
not yet recognized by the optimizer.
collection(...)[ predicate ]
: a predicate (e.g
full-text) directly on a collection, returning document nodes.Transaction concurrency: it was possible to get a duplicate document if it was modified by 2 different transactions without locking. The fix checks that situation and silently deletes the older version.
Notice that this fix still does not provide a full support of "Optimistic Concurrency", because it does not guarantee Consistency: locks must be used for that purpose.
//foo[ *[2]/bar ]
could be
compiled in an invalid way.//*[not(self::foo)]
could produce an NPE.A query on a document just imported in an XML Library, without commit, could fail because the query compiler was attempting to use indexes while in fact the document is not yet indexed.
Reminder: in any case, it is better to do queries after a commit, because otherwise indexes for newly loaded documents are not yet available, hence slower query execution.
A JVM version 6+ is now required to run Qizx.
The API is mainly unchanged, except a few additions listed hereafter.
A Content Importer is a parser for 'semi-structured' content format, converting it to XML.
Qizx 4.2 contains importers for JSON, HTML through TagSoup (jar included), HTML5 (available as a separate package).
Content can be imported as XML with the
extension function x:content-parse(data, format,
options)
.
Other importers are planned in future versions: Mime mail, CSV
JSON data is converted to XML (proprietary schema) through a
particular Content Importer, hence parsing is achieved with
x:content-parse(data, "json")
.
Serializing
JSON-as-XML back to JSON format is achieved through function
x:serialize-json()
.
From 4.2, Qizx supports extensions specified by the EXPath initiative.
Documentation for these modules can be found in the Developer Guide, as well as on the EXPath site.
"Packaging System": EXPath Packaging provides a framework for describing library or application packages, independent of the XQuery platform.
Packages can contain not only XQuery modules, but also XSLT2 and XProc modules. Modules are referenced only through their public URIs.
EXPath includes tools for creating packages.
In addition, the Qizx implementation of EXPath Packaging System supports Qizx-specific modules, such as Content Importers (see above) and the "zip" package (see below).
We will keep expanding this support with packages such as:
http-client a set of extension functions for communicating with HTTP servers,
The Java API now supports extended configuration methods on
LibraryManager
and XQuerySessionManager
, by
which a number of properties can be specified, in particular runtime
parameters and implementations of add-ons.
A new class
Configuration
replaces LibraryManagerFactory as bootstrap
mechanism.
This facility is supported in tools (qizx and
QizxStudio) through option -config
, and in Qizx
Server.
Qizx 4.2 includes significant optimizations for large databases of small documents. These improvements were required by a customer use-case involving databases of more than 100 millions documents (2Kb each), with demanding performance goals in bulk-load, queries and updates.
group by
and order by
now require much less memory (at least 10
times less). The problem was appearing when trying to group or sort
nodes belonging to tens of thousands of documents in a database. It is
now feasible to sort from 1 million documents, while still requiring a
sizable amount of memory (about 600 Mb).Note that fine-tuning the configuration (see above) can help optimize bulk-load: please ask us for advice.
These conditions apply to any product sold or distributed starting from March 1, 2011.
Terms of licenses have been rewritten for more accuracy.
See present licenses for applicable terms.
Price-list and renewal conditions have been changed.
Our policy is to adapt prices in accordance with the development of functionalities. Please note that prices had not been changed since the introduction of Qizx in 2008.
Maintenance release.
Database bulk store: in rare cases, the occurrence count per
document -stored in indexes- could be 0, leading to slightly incorrect
values returned by count(), for example
count(//SomeElement)
on the whole database. This would
happen only if documents were indexed by batches of 4096 or more.
Implemented XQuery 1.1 Features: functions as items, group by, for window, try catch, switch, output declarations.
Yet to implement: count clause in FLWOR, computed namespace constructors, formatting and miscellaneous functions.
Support of non-XML documents: Qizx can now store documents containing any binary data. They are similar to "Blobs" of relational databases, and can be used for example to store images or plain text. Access is sequential, compression can be used as an option.
Scalability and efficiency: Qizx has been validated on very large databases and documents. Improvements have been made to reduce memory consumption and bottlenecks.
A new "Extra Large" (XL) edition of Qizx is available through scripts qizx-xl and qizxstudio-xl (using qizxxl.jar). It can handle very large documents (up to 1 Terabyte, instead of 2 Gigabytes for the standard version).
Qizx has been validated with a 100 million-documents database, representing about 330 Gigabytes of FpML data.
A 44 Gigabyte document has been stored and indexed, using the specific "XL" edition (jar qizx64.jar). This edition has a theoretical limit of 1 Terabyte approximately for a single document, instead of 2 Gb in the standard version).
Improved recovery and cleanup after crashes (notably OutOfMemory in QizxStudio or qizx with local databases).
Server installation wizard: Qizx Server bundled with a Servlet container is installable very easily using a wizard.
The manual installation has been made simpler; the (buggy) former script mkserver has been discarded.
(1 to 5)[let
$x := position() return $x]
said " variable x not declared".Qizx Server:
Qizx Server makes the embeddable XML database engine accessible to remote clients through a set of interfaces:
API service exposes the main capabilities of the Qizx engine to clients implemented on any platform that supports HTTP client requests: front-end servers in PHP, JSP. .NET languages etc, heavy clients running on any platform.
The architecture implied by this service is similar to many applications using a SQL back-end server.
XQuery Services is a mechanism for calling XQuery scripts stored on the server, passing parameters.
It can be used to implement lightweight Web Services-like applications, or to implement business logic middle tiers.
All services are based on a HTTP REST-style protocol.
They are extensible and their source code is available.
See documentation for more details.
Qizx Studio and the command-line tool qizx
have
been enhanced to work with the API service, thus providing remote
administration tools.
Qizx Studio editor has been improved (undo, redo, save, save as). The query history is suppressed.
In Qizx/open, both tools are able to connect to a server (browsing and remote execution).
Preliminary support of XQuery Scripting. No support yet for validity checks and Update semantics.
Moved to Java 5. A JVM version 5+ is now required to run Qizx (Java 6 recommended because of XML parser issues and better Unicode support).
The API is unchanged, except minor enhancements listed here.
A noxious bug that appeared under very heavy load, with many threads performing transactions concurrently, and that could corrupt an XML Library (reported by Lóránt Pintér).
This new version has been tested with over 200 threads.
Introduced a limit to the number of index segments created when a large number of threads perform transactions simultaneously. The multiplication of index segments increases memory consumption and could provoke OutOfMemoryException's.
Also fixed 2 memory leaks contributing to these OOME.
Support of the standard XQuery Full-Text functionalities. This new W3C Recommendation provides a comprehensive specification for full-text search, well integrated with the XQuery language.
The new full-text functionalities in Qizx are a nearly complete implementation of the standard, with an execution speed slightly improved with respect to the former implementation. Documentation can be found in the User's Manual section of the documentation. A new tutorial is available here if you wish to get acquainted with this language extension.
Attention: the former support of full-text in Qizx 2.x, based on extension functions, has been completely withdrawn. To help migrating your applications, we have written a dedicated chapter in the documentation: "Migration Guide from former Full-Text implementation". Version 3.1 might restore the former full-text functions as a layer on top of new full-text, but only if we feel a demand from our users.
Data conversions in Indexing Specifications were not used when the query is not indexable, leading to inconsistent execution errors.
Note: this data conversion mechanism is actually an extension of XQuery and goes beyond XML Schema. It is not yet available in Qizx/open.
For example assuming that Indexing Specifications are
able to recognize and convert dates written like "12/31/99" in element
and attributes values, a non-indexable query like //*[date =
xs:date("1999-12-31")]
did generate an error, whereas the
indexable query //event[date = xs:date("1999-12-31")]
was
working as expected.
Qizx 2.2 has a new licensing scheme and a new price list.
XQuery Update: Updating Expressions within most operators (except FLOWR, if, typeswitch, comma) are illegal but errors were not raised. As a consequence, some (invalid) expressions silently failed to execute. For example an Updating Expression within a node constructor, which is not allowed by the language, could not be executed.
countItems() was counting nodes barred by Access Control, skip() was not consistent with moveToNextItem(). Now all methods take AccessControl into account, possibly with some speed penalty.
for example
deleteMember("/a")
followed by renameMember("/b",
"/a")
generated an error claiming that "/a" was still
existing.
XQuery Update: Qizx 2.1 fully supports the XQuery Update Facility draft specifications.
This implementation passes 100% of the current XQUF Test Suite.
First release.