XML or some other format. XPath is the \e{element selection} part
of XQuery.
- The QtXmlPatterns module supports using
+ The Qt XML Patterns module supports using
\l{http://www.w3.org/TR/xquery} {XQuery 1.0} and
\l{http://www.w3.org/TR/xpath20} {XPath 2.0} in Qt applications,
for querying XML data \e{and} for querying
Readers who are not familiar with the XQuery/XPath language can read
\l {A Short Path to XQuery} for a brief introduction.
- \section1 Advantages of using QtXmlPatterns and XQuery
+ \section1 Advantages of using Qt XML Patterns and XQuery
The XQuery/XPath language simplifies data searching and
transformation tasks by eliminating the need for doing a lot of
as an attribute. Finally, the \c{<bibliography>} element is
closed.
- The advantages of using QtXmlPatterns and XQuery in your Qt
+ The advantages of using Qt XML Patterns and XQuery in your Qt
programs are summarized as follows:
\list
data searching, selecting, and sorting tasks.
\li \b{Conformance to standards}: Conformance to all applicable
- XML and XQuery standards ensures that QtXmlPatterns can always
+ XML and XQuery standards ensures that Qt XML Patterns can always
process XML documents generated by other conformant
- applications, and that XML documents created with QtXmlPatterns
+ applications, and that XML documents created with Qt XML Patterns
can be processed by other conformant applications.
- \li \b{Maximal flexibility} The QtXmlPatterns module can be used
+ \li \b{Maximal flexibility} The Qt XML Patterns module can be used
to query XML data \e{and} non-XML data that can be
\l{QAbstractXmlNodeModel} {modeled to look like XML}.
\endlist
- \section1 Using the QtXmlPatterns module
+ \section1 Using the Qt XML Patterns module
- There are two ways QtXmlPatterns can be used to evaluate queries.
+ There are two ways Qt XML Patterns can be used to evaluate queries.
You can run the query engine in your Qt application using the
- QtXmlPatterns C++ API, or you can run the query engine from the
+ Qt XML Patterns C++ API, or you can run the query engine from the
command line using Qt's \c{xmlpatterns} command line utility.
\section2 Running the query engine from your Qt application
If we save the example XQuery shown above in a text file (e.g.
\c{myquery.xq}), we can run it from a Qt application using a
- standard QtXmlPatterns code sequence:
+ standard Qt XML Patterns code sequence:
\snippet doc/src/snippets/code/src_xmlpatterns_api_qxmlquery.cpp 3
the \l{QXmlQuery::}{evaluateTo()} function to evaluate the query
and serialize the results as XML.
- \note If you compile Qt yourself, the QtXmlPatterns module will
+ \note If you compile Qt yourself, the Qt XML Patterns module will
\e{not} be built if exceptions are disabled, or if you compile Qt
with a compiler that doesn't support member templates, e.g., MSVC
6.
See the QXmlQuery documentation for more information about the
- QtXmlPatterns C++ API.
+ Qt XML Patterns C++ API.
\section2 Running the query engine from the command line utility
\target qtxmlpatterns_example_query2
\quotefile snippets/patternist/introExample2.xq
- Modify the QtXmlPatterns code to use one of the \l{QXmlQuery::}
+ Modify the Qt XML Patterns code to use one of the \l{QXmlQuery::}
{bindVariable()} functions to bind a program variable to each
XQuery $variable:
\snippet doc/src/snippets/code/src_xmlpatterns_api_qxmlquery.cpp 4
- Each program variable is passed to QtXmlPatterns as a QVariant of
+ Each program variable is passed to Qt XML Patterns as a QVariant of
the type of the C++ variable or constant from which it is
- constructed. Note that QtXmlPatterns assumes that the type of the
+ constructed. Note that Qt XML Patterns assumes that the type of the
QVariant in the bindVariable() call is the correct type, so the
$variable it is bound to must be used in the XQuery accordingly.
The following table shows how QVariant types are mapped to XQuery
{QXmlResultItems} {result items}, atomic values in the sequence
are treated as instances of QVariant. Suppose that instead of
serializing the results of the XQuery as XML, we process the
- results programatically. Modify the standard QtXmlPatterns code
+ results programatically. Modify the standard Qt XML Patterns code
sequence to call the overload of QXmlQuery::evaluateTo() that
populates a sequence of \l {QXmlResultItems} {result items} with
the XQuery results:
\section1 Using XQuery with Non-XML Data
Although the XQuery language was designed for querying XML, with
- QtXmlPatterns one can use XQuery for querying any data that can
+ Qt XML Patterns one can use XQuery for querying any data that can
be modeled to look like XML. Non-XML data is modeled to look like
XML by loading it into a custom subclass of QAbstractXmlNodeModel,
- where it is then presented to the QtXmlPatterns XQuery engine via
+ where it is then presented to the Qt XML Patterns XQuery engine via
the same API the XQuery engine uses for querying XML.
- When QtXmlPatterns loads and queries XML files and produces XML
+ When Qt XML Patterns loads and queries XML files and produces XML
output, it can always load the XML data into its default XML node
model, where it can be traversed efficiently. The XQuery below
traverses the product orders found in the XML file \e myOrders.xml
\quotefile snippets/patternist/introAcneRemover.xq
- QtXmlPatterns can be used out of the box to perform this
+ Qt XML Patterns can be used out of the box to perform this
query, provided \e myOrders.xml actually contains well-formed XML. It
can be loaded directly into the default XML node model and
- traversed. But suppose we want QtXmlPatterns to perform queries on
+ traversed. But suppose we want Qt XML Patterns to perform queries on
the hierarchical structure of the local file system. The default
- XML node model in QtXmlPatterns is not suitable for navigating the
+ XML node model in Qt XML Patterns is not suitable for navigating the
file system, because there is no XML file to load that contains a
description of it. Such an XML file, if it existed, might look
something like this:
\skipto <html>
\printuntil
- Without QtXmlPatterns, there is no simple way to solve this kind
+ Without Qt XML Patterns, there is no simple way to solve this kind
of problem. You might do it by writing a C++ program to traverse
the file system, sniff out all the XML files, and submit each one
to an XML parser to test that it contains valid XML. The C++ code
step system that results is inefficient because the two data
models must be built and maintained separately.
- With QtXmlPatterns, subclassing QAbstractXmlNodeModel eliminates
+ With Qt XML Patterns, subclassing QAbstractXmlNodeModel eliminates
the transformation required to convert the non-XML data model to
the XML data model, because there is only ever one data model
required. The non-XML data model presents the non-XML data to the
system.
Examples of other places where XQuery could be used in
- QtXmlPatterns to query non-XML data:
+ Qt XML Patterns to query non-XML data:
\list
See the QAbstractXmlNodeModel documentation for information about
how to implement custom XML node models.
- \section1 More on using QtXmlPatterns with non-XML Data
+ \section1 More on using Qt XML Patterns with non-XML Data
Subclassing QAbstractXmlNodeModel to let the query engine access
non-XML data by the same API it uses for XML is the feature that
- enables QtXmlPatterns to query non-XML data with XQuery. It allows
+ enables Qt XML Patterns to query non-XML data with XQuery. It allows
XQuery to be used as a mapping layer between different non-XML
node models or between a non-XML node model and the built-in XML
node model. Once the subclass(es) of QAbstractXmlNodeModel have
data in several different formats. Rather than writing a lot of
C++ code to convert each input format to an intermediate form, and
more C++ code to convert the intermediate form back to each
- output format, one can implement a solution based on QtXmlPatterns
+ output format, one can implement a solution based on Qt XML Patterns
that uses simple XQueries to transform each XML or non-XML format
(e.g. MathFormula.xml below) to the intermediate form (e.g. the
DocumentRepresentation node model class below), and more simple
\section2 Denial of Service Attacks
- Applications using QtXmlPatterns are subject to the same
+ Applications using Qt XML Patterns are subject to the same
limitations of software as other systems. Generally, these can not
- be checked. This means QtXmlPatterns does not prevent rogue
+ be checked. This means Qt XML Patterns does not prevent rogue
queries from consuming too many resources. For example, a query
could take too much time to execute or try to transfer too much
data. A query could also do too much recursion, which could crash
\section2 XQuery 1.0
- QtXmlPatterns aims at being a
+ Qt XML Patterns aims at being a
\l{http://www.w3.org/TR/xquery/#id-xquery-conformance} {conformant
XQuery processor}. It adheres to
\l{http://www.w3.org/TR/xquery/#id-minimal-conformance} {Minimal
\l{http://www.w3.org/TR/xquery/#id-serialization-feature}
{Serialization Feature} and the
\l{http://www.w3.org/TR/xquery/#id-full-axis-feature} {Full Axis
- Feature}. QtXmlPatterns currently passes 97% of the tests in the
+ Feature}. Qt XML Patterns currently passes 97% of the tests in the
\l{http://www.w3.org/XML/Query/test-suite} {XML Query Test Suite}.
Areas where conformance may be questionable and where behavior may
be changed in future releases include:
are incorrect.
\li XPath is a subset of XQuery and the implementation of
- QtXmlPatterns uses XPath 2.0 with XQuery 1.0.
+ Qt XML Patterns uses XPath 2.0 with XQuery 1.0.
\endlist
\section2 XSLT 2.0
Partial support for XSLT was introduced in Qt 4.5. Future
- releases of QtXmlPatterns will aim to support these XSLT
+ releases of Qt XML Patterns will aim to support these XSLT
features:
\list
in the following table. The implementation of XSLT in Qt 4.5 can
be seen as XSLT 1.0 but with the data model of XPath 2.0 and
XSLT 2.0, and using the using the functionality of XPath 2.0 and
- its accompanying function library. When QtXmlPatterns encounters
+ its accompanying function library. When Qt XML Patterns encounters
an unsupported or partially support feature, it will either report
a syntax error or silently continue, unless otherwise noted in the
table.
\li Since XPath is a subset of XSLT, its issues are in affect too.
\endtable
- The QtXmlPatterns implementation of the XPath Data Model does not
+ The Qt XML Patterns implementation of the XPath Data Model does not
include entities (due to QXmlStreamReader not reporting them).
This means that functions \c unparsed-entity-uri() and \c
unparsed-entity-public-id() always return negatively.
\section2 XML Schema 1.0
- There are two ways QtXmlPatterns can be used to validate schemas:
+ There are two ways Qt XML Patterns can be used to validate schemas:
You can use the C++ API in your Qt application using the classes
QXmlSchema and QXmlSchemaValidator, or you can use the command line
utility named xmlpatternsvalidator (located in the "bin" directory
of your Qt build).
- The QtXmlPatterns implementation of XML Schema validation supports
+ The Qt XML Patterns implementation of XML Schema validation supports
the schema specification version 1.0 in large parts. Known problems
of the implementation and areas where conformancy may be questionable
are:
\section2 Resource Loading
- When QtXmlPatterns loads an XML resource, e.g., using the
+ When Qt XML Patterns loads an XML resource, e.g., using the
\c fn:doc() function, the following schemes are supported:
\table
/*!
\namespace QPatternist
- \brief The QPatternist namespace contains classes and functions required by the QtXmlPatterns module.
+ \brief The QPatternist namespace contains classes and functions required by the Qt XML Patterns module.
\internal
*/
or more \e{steps} separated by slash '/' or double slash '//'.
Although path expressions are used for traversing XML trees, not file
systems, in QtXmlPatterms we can model a file system to look like an
-XML tree, so in QtXmlPatterns we can use XQuery to traverse a file
+XML tree, so in Qt XML Patterns we can use XQuery to traverse a file
system. See the \l {File System Example} {file system example}.
Think of a path expression as an algorithm for traversing an XML tree
\l{http://www.w3.org/TR/xquery/#id-document-order} {document order}
and without duplicates.
-With QtXmlPatterns, a standard way to present the initial focus to a
+With Qt XML Patterns, a standard way to present the initial focus to a
query is to call QXmlQuery::setFocus(). Another common way is to let
the XQuery itself create the initial focus by using the first step of
the path expression to call the XQuery \c{doc()} function. The
\section2 Axis Specifiers
An axis specifier defines the direction you want the query engine to
-take, when it navigates away from the context node. QtXmlPatterns
+take, when it navigates away from the context node. Qt XML Patterns
supports the following axes.
\table
kind of node and the \e name of the node. The XQuery specification for
\l{http://www.w3.org/TR/xquery/#node-tests} {node tests} also defines
a third condition, the node's \e {Schema Type}, but schema type tests
-are not supported in QtXmlPatterns.
+are not supported in Qt XML Patterns.
-QtXmlPatterns supports the following node tests. The tests that have a
+Qt XML Patterns supports the following node tests. The tests that have a
\c{name} parameter test the node's name in addition to its \e{kind}
and are often called the \l{Name Tests}.
But note how the output is slightly different from the output we saw
before we added the default namespace declaration to the cookbook file.
-QtXmlPatterns automatically includes the correct namespace attribute
-in each \c{<title>} element in the output. When QtXmlPatterns loads a
+Qt XML Patterns automatically includes the correct namespace attribute
+in each \c{<title>} element in the output. When Qt XML Patterns loads a
document and expands a QName, it creates an instance of QXmlName,
which retains the namespace prefix along with the namespace URI and
the local name. See QXmlName for further details.
One thing to keep in mind from this namespace discussion, whether you
-run XQueries in a Qt program using QtXmlPatterns, or you run them from
+run XQueries in a Qt program using Qt XML Patterns, or you run them from
the command line using xmlpatterns, is that if you don't get the
output you expect, it might be because the data you are querying uses
namespaces, but you didn't declare those namespaces in your XQuery.
projects / profile / ivi / qtxmlpatterns.git / commitdiff