SAXONICA

Saxon Documentation
Full Contents
About Saxon
Changes in this Release
| Version 9.1 (2008-07-02)
» | Version 9.0 (2007-11-03)
Notices
Using XSLT 2.0
Using XQuery
Handling Source Documents
XML Schema Processing
XPath API for Java
Saxon on .NET
Extensibility
Saxon Extensions
Sample Saxon Applications
The Saxon SQL Extension
XSLT Elements
XPath 2.0 Expression Syntax
Function Library
Standards Conformance

# Changes to existing APIs

The behavior of `configuration.buildDocument()` has changed for cases where the supplied `Source` object is a tree. In particular, if it is a `DOMSource` then the DOM Document node will normally be wrapped in a Saxon wrapper object rather than being copied to a TinyTree. This has the effect of reinstating the pre-8.9 behaviour of methods in the XPath API that are given a DOMSource as an argument; the XPath expressions will now return nodes in the original DOM tree rather than copies of these nodes.

Support for DOM Level 2 implementations has been reinstated; however Saxon no longer attempts to detect whether the DOM supports level 3 interfaces; instead, when a Level 2 DOM implementation is used, the configuration setting `config.setDOMLevel(2)` must be used. (Saxon now has compile-time references to DOM level 3 methods, but will not call such methods if this configuration setting is in force.)

The class `StaticQueryContext` has been split into two: user-facing methods used to initialize the context for a query are still in `StaticQueryContext`, but methods intended for system use, which update the context as declarations in the query prolog are parsed, have been moved to a new class `QueryModule`. The class `StaticQueryContext` no longer implements the `StaticContext` interface.

As part of the above change, some methods on `StaticQueryContext` have been dropped. This notably includes the method `declareVariable()` which never worked in a satisfactory way because the variable was not reusable across multiple queries. External variables should always be declared from the query prolog.

A new factory method `Configuration.makeConfiguration()` is available. This creates a schema-aware configuration if Saxon-SA is installed and licensed, otherwise it creates a non-schema-aware configuration. This option is useful for applications that want to take advantage of the enhanced Saxon-SA optimizer in cases where it is available, but do not otherwise depend on Saxon-SA functionality.

A new method on `Configuration` is introduced to copy a `Configuration`. The main motivation for this is to eliminate the high cost of repeatedly checking the Saxon-SA license key in applications that create many separate Configurations.

The rule that all documents used within a single query, transformation, or XPath expression must be built using the same `Configuration` has been relaxed slightly, so the requirement is only that they must be "compatible" Configurations, which means in practice that they must use the same `NamePool` and `DocumentNumberAllocator`. Although the rule has been relaxed slightly, it is also now enforced on a number of interfaces where previously no checking took place (which could lead to unpredictable failures later). This applies in particular to XPath APIs.

A new option is available in the `Configuration` to indicate that calls to the `doc()` or `document()` functions with constant string arguments should be evaluated when a query or stylesheet is compiled, rather than at run-time. This option is intended for use when a reference or lookup document is used by all queries and transformations. Using this option has a number of effects: (a) the URI is resolved using the compile-time URIResolver rather than the run-time URIResolver; (b) the document is loaded into a document pool held by the `Configuration`, whose memory is released only when the `Configuration` itself ceases to exist; (c) all queries and transformations using this document share the same copy; (d) any updates to the document that occur between compile-time and run-time have no effect. The option is selected by using `Configuration.setConfigurationProperty()`\ or `TransformerFactory.setAttribute()` with the property name `FeatureKeys.PRE_EVALUATE_DOC_FUNCTION`. This option is not available from the command line because it has no useful effect with a single-shot compile-and-run interface.

A convenience method `QueryResult.serialize(NodeInfo node)` has been provided, allowing a node to be serialized as XML; the result is returned as a String.

There is also a convenience method `Navigator.getAttributeValue(NodeInfo node, String uri, String localName)` making it easier for Java applications to get an attribute of an element.

In the `NodeInfo` interface, the rules for the `copy()` method have changed so that when an element is copied, its namespaces must be output without duplicates (or without a declaration being cancelled by an undeclaration). The method no longer relies on the recipient removing such duplicates.

The method `NodeInfo#sendNamespaceDeclarations` has been deleted.

The class `NameTest` has a new constructor taking a URI and local name as strings, making it easier to construct a `NameTest` for use in calls to `iterateAxis()`. In addition, the abstract class `NodeTest` now has only one abstract method, making it easier to write a user-defined implementation of `NodeTest` for filtering the nodes returned by `iterateAxis()`.

Methods that construct or convert atomic values no longer return ValidationErrorValue in the event of a failure. There were a couple of problems with this mechanism: although it was designed to eliminate the costs of throwing an exception, it failed to take into account the cost of creating the exception before throwing it, which is surprisingly expensive as it involves capturing a stack trace. Secondly, the mechanism wasn't type safe as it didn't force callers to check the return value for an error. These methods (and a number of others) now return a `ConversionResult` which is essentially a union type of `AtomicValue` and `ValidationFailure`. Code calling these methods therefore has to consciously cast the result to `AtomicValue`, preferably after checking that the result is not a `ValidationFailure`.

The two exception classes `StaticError` and `DynamicError` are no longer used: instead, their common base class `XPathExpression` is now a concrete class and is used to represent both static and dynamic errors. It includes a field to distinguish the two cases, though in fact there is very little code that cares about the difference (the only time the difference is significant is when dynamic errors occur during early compile-time evaluation of constant subexpressions). Any application code that contains a catch for `StaticError` or `DynamicError` should be changed to catch `XPathException` instead. Since nearly all API methods declared "throws XPathException" already, this is unlikely to be a major issue.

There has been some tidying up of methods on the `AtomicValue` class, especially methods for converting values between types and for setting the type label.

The .NET API

In the .NET API, the class `XsltCompiler` now has an overload of the `Compile()` method that takes input from a `TextReader` (for example, a `StringReader`).

The class `XdmAtomicValue` now has a static factory method that constructs an "external object", that is, an XPath wrapper around a .NET object. This can be passed as a parameter to a stylesheet or query and used as an argument to extension functions.

The class `TextWriterDestination` (despite its name, which is unchanged) now wraps any `XmlWriter`. It was previously restricted to wrap an `XmlTextWriter`.

The XQJ API

Saxon's implementation of the XQuery API for Java (XQJ) (jsr-225) has been upgraded to conform to the version 0.9 specifications released on 12 June 2007. The specifications can be downloaded at http://jcp.org/en/jsr/detail?id=225. There are some incompatibilities: applications will need to be changed, though probably not extensively.

Please note that this API is still a draft, and Saxon's implementation will change when the specifications change.

Next