1 /****************************************************************************
3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/
6 ** This file is part of the documentation of the Qt Toolkit.
8 ** $QT_BEGIN_LICENSE:FDL$
9 ** GNU Free Documentation License
10 ** Alternatively, this file may be used under the terms of the GNU Free
11 ** Documentation License version 1.3 as published by the Free Software
12 ** Foundation and appearing in the file included in the packaging of
16 ** Alternatively, this file may be used in accordance with the terms
17 ** and conditions contained in a signed written agreement between you
26 ****************************************************************************/
29 \page xmlprocessing.html
32 \previouspage Working with the DOM Tree
33 \contentspage XML Processing
37 \brief An overview of Qt's support for using XML technologies in
42 \section1 Introduction
44 XQuery is a language for traversing XML documents to select and
45 aggregate items of interest and to transform them for output as
46 XML or some other format. XPath is the \e{element selection} part
49 The Qt XML Patterns module supports using
50 \l{http://www.w3.org/TR/xquery} {XQuery 1.0} and
51 \l{http://www.w3.org/TR/xpath20} {XPath 2.0} in Qt applications,
52 for querying XML data \e{and} for querying
53 \l{QAbstractXmlNodeModel} {non-XML data that can be modeled to
55 Readers who are not familiar with the XQuery/XPath language can read
56 \l {A Short Path to XQuery} for a brief introduction.
58 \section1 Advantages of using Qt XML Patterns and XQuery
60 The XQuery/XPath language simplifies data searching and
61 transformation tasks by eliminating the need for doing a lot of
62 C++ or Java procedural programming for each new query task. Here
63 is an XQuery that constructs a bibliography of the contents of a
66 \target qtxmlpatterns_example_query
67 \quotefile patternist/introductionExample.xq
69 First, the query opens a \c{<bibliography>} element in the
71 \l{xquery-introduction.html#using-path-expressions-to-match-and-select-items}
72 {embedded path expression} then loads the XML document describing
73 the contents of the library (\c{library.xml}) and begins the
74 search. For each \c{<book>} element it finds, where the publisher
75 was Addison-Wesley and the publication year was after 1991, it
76 creates a new \c{<book>} element in the output as a child of the
77 open \c{<bibliography>} element. Each new \c{<book>} element gets
78 the book's title as its contents and the book's publication year
79 as an attribute. Finally, the \c{<bibliography>} element is
82 The advantages of using Qt XML Patterns and XQuery in your Qt
83 programs are summarized as follows:
87 \li \b{Ease of development}: All the C++ programming required to
88 perform data query tasks can be replaced by a simple XQuery
89 like the example above.
91 \li \b{Comprehensive functionality}: The
92 \l{http://www.w3.org/TR/xquery/#id-expressions} {expression
93 syntax} and rich set of
94 \l{http://www.w3.org/TR/xpath-functions} {functions and
95 operators} provided by XQuery are sufficient for performing any
96 data searching, selecting, and sorting tasks.
98 \li \b{Conformance to standards}: Conformance to all applicable
99 XML and XQuery standards ensures that Qt XML Patterns can always
100 process XML documents generated by other conformant
101 applications, and that XML documents created with Qt XML Patterns
102 can be processed by other conformant applications.
104 \li \b{Maximal flexibility} The Qt XML Patterns module can be used
105 to query XML data \e{and} non-XML data that can be
106 \l{QAbstractXmlNodeModel} {modeled to look like XML}.
110 \section1 Using the Qt XML Patterns module
112 There are two ways Qt XML Patterns can be used to evaluate queries.
113 You can run the query engine in your Qt application using the
114 Qt XML Patterns C++ API, or you can run the query engine from the
115 command line using Qt's \c{xmlpatterns} command line utility.
117 \section2 Running the query engine from your Qt application
119 If we save the example XQuery shown above in a text file (e.g.
120 \c{myquery.xq}), we can run it from a Qt application using a
121 standard Qt XML Patterns code sequence:
123 \snippet code/src_xmlpatterns_api_qxmlquery.cpp 3
125 First construct a QFile for the text file containing the XQuery
126 (\c{myquery.xq}). Then create an instance of QXmlQuery and call
127 its \l{QXmlQuery::}{setQuery()} function to load and parse the
128 XQuery file. Then create an \l{QXmlSerializer} {XML serializer} to
129 output the query's result set as unformatted XML. Finally, call
130 the \l{QXmlQuery::}{evaluateTo()} function to evaluate the query
131 and serialize the results as XML.
133 \note If you compile Qt yourself, the Qt XML Patterns module will
134 \e{not} be built if exceptions are disabled, or if you compile Qt
135 with a compiler that doesn't support member templates, e.g., MSVC
138 See the QXmlQuery documentation for more information about the
139 Qt XML Patterns C++ API.
141 \section2 Running the query engine from the command line utility
143 \e xmlpatterns is a command line utility for running XQueries. It
144 expects the name of a file containing the XQuery text.
146 \snippet code/doc_src_qtxmlpatterns.qdoc 2
148 The XQuery in \c{myQuery.xq} will be evaluated and its output
149 written to \c stdout. Pass the \c -help switch to get the list of
150 input flags and their meanings.
152 xmlpatterns can be used in scripting. However, the descriptions
153 and messages it outputs were not meant to be parsed and may be
154 changed in future releases of Qt.
157 \section1 The XQuery Data Model
159 XQuery represents data items as \e{atomic values} or \e{nodes}. An
160 atomic value is a value in the domain of one of the
161 \l{http://www.w3.org/TR/xmlschema-2/#built-in-datatypes} {built-in
162 datatypes} defined in \l{http://www.w3.org/TR/xmlschema-2} {Part
163 2} of the W3C XML Schema. A node is normally an XML element or
164 attribute, but when non-XML data is \l{QAbstractXmlNodeModel}
165 {modeled to look like XML}, a node can also represent a non-XML
168 When you run an XQuery using the C++ API in a Qt application, you
169 will often want to bind program variables to $variables in the
170 XQuery. After the query is evaluated, you will want to interpret
171 the sequence of data items in the result set.
173 \section2 Binding program variables to XQuery variables
175 When you want to run a parameterized XQuery from your Qt
176 application, you will need to \l{QXmlQuery::bindVariable()} {bind
177 variables} in your program to $name variables in your XQuery.
179 Suppose you want to parameterize the bibliography XQuery in the
180 example above. You could define variables for the catalog that
181 contains the library (\c{$file}), the publisher name
182 (\c{$publisher}), and the year of publication (\c{$year}):
184 \target qtxmlpatterns_example_query2
185 \quotefile patternist/introExample2.xq
187 Modify the Qt XML Patterns code to use one of the \l{QXmlQuery::}
188 {bindVariable()} functions to bind a program variable to each
191 \snippet code/src_xmlpatterns_api_qxmlquery.cpp 4
193 Each program variable is passed to Qt XML Patterns as a QVariant of
194 the type of the C++ variable or constant from which it is
195 constructed. Note that Qt XML Patterns assumes that the type of the
196 QVariant in the bindVariable() call is the correct type, so the
197 $variable it is bound to must be used in the XQuery accordingly.
198 The following table shows how QVariant types are mapped to XQuery
205 \li XQuery $variable type
208 \li QVariant::LongLong
217 \li \c xs:nonNegativeInteger
220 \li QVariant::ULongLong
221 \li \c xs:unsignedLong
240 \li QVariant::ByteArray
241 \li \c xs:base64Binary
244 \li QVariant::StringList
256 \li QVariant::DateTime
261 \li \c xs:time. (see \l{Binding To Time}{Binding To
262 QVariant::Time} below)
266 \li (see \l{Binding To QVariantList}{Binding To QVariantList}
271 A type not shown in the table is not supported and will cause
272 undefined XQuery behavior or a $variable binding error, depending
273 on the context in the XQuery where the variable is used.
275 \target Binding To Time
276 \section3 Binding To QVariant::Time
278 Because the instance of QTime used in QVariant::Time does not
279 include a zone offset, an instance of QVariant::Time should not be
280 bound to an XQuery variable of type \c xs:time, unless the QTime is
281 UTC. When binding a non-UTC QTime to an XQuery variable, it should
282 first be passed as a string, or converted to a QDateTime with an arbitrary
283 date, and then bound to an XQuery variable of type \c xs:dateTime.
285 \target Binding To QVariantList
286 \section3 Binding To QVariantList
288 A QVariantList can be bound to an XQuery $variable. All the
289 \l{QVariant}s in the list must be of the same atomic type, and the
290 $variable the variant list is bound to must be of that same atomic
291 type. If the QVariants in the list are not all of the same atomic
292 type, the XQuery behavior is undefined.
294 \section2 Interpreting XQuery results
296 When the results of an XQuery are returned in a sequence of \l
297 {QXmlResultItems} {result items}, atomic values in the sequence
298 are treated as instances of QVariant. Suppose that instead of
299 serializing the results of the XQuery as XML, we process the
300 results programatically. Modify the standard Qt XML Patterns code
301 sequence to call the overload of QXmlQuery::evaluateTo() that
302 populates a sequence of \l {QXmlResultItems} {result items} with
305 \snippet code/src_xmlpatterns_api_qxmlquery.cpp 5
307 Iterate through the \l {QXmlResultItems} {result items} and test
308 each QXmlItem to see if it is an atomic value or a node. If it is
309 an atomic value, convert it to a QVariant with \l {QXmlItem::}
310 {toAtomicValue()} and switch on its \l {QVariant::type()} {variant
311 type} to handle all the atomic values your XQuery might return.
312 The following table shows the QVariant type to expect for each
313 atomic value type (or QXmlName):
318 \li XQuery result item type
319 \li QVariant type returned
323 \li QXmlName (see \l{Handling QXmlNames}{Handling QXmlNames}
328 \li QVariant::LongLong
336 \li QVariant::StringList
356 \li QVariant::ByteArray
359 \li \c xs:base64Binary
360 \li QVariant::ByteArray
364 \li QVariant::DateTime
368 \li QVariant::DateTime
372 \li QVariant::DateTime
376 \li QVariant::DateTime
380 \li QVariant::DateTime
387 \li \c xs:untypedAtomic
396 \li QVariant::DateTime
400 \li QVariant::DateTime
404 \li (see \l{xstime-not-mapped}{No mapping for xs:time} below)
408 \target Handling QXmlNames
409 \section3 Handling QXmlNames
411 If your XQuery can return atomic value items of type \c{xs:QName},
412 they will appear in your QXmlResultItems as instances of QXmlName.
413 Since the QVariant class does not support the QXmlName class
414 directly, extracting them from QXmlResultItems requires a bit of
415 slight-of-hand using the \l{QMetaType} {Qt metatype system}. We
416 must modify our example to use a couple of template functions, a
417 friend of QMetaType (qMetaTypeId<T>()) and a friend of QVariant
418 (qvariant_cast<T>()):
420 \snippet code/src_xmlpatterns_api_qxmlquery.cpp 6
422 To access the strings in a QXmlName returned by an
423 \l{QXmlQuery::evaluateTo()} {XQuery evaluation}, the QXmlName must
424 be accessed with the \l{QXmlNamePool} {name pool} from the
425 instance of QXmlQuery that was used for the evaluation.
427 \target xstime-not-mapped
428 \section3 No mapping for xs:time
430 An instance of \c xs:time can't be represented correctly as an
431 instance of QVariant::Time, unless the \c xs:time is a UTC time.
432 This is because xs:time has a zone offset (0 for UTC) in addition
433 to the time value, which the QTime in QVariant::Time does not
434 have. This means that if an XQuery tries to return an atomic value
435 of type \c xs:time, an invalid QVariant will be returned. A query
436 can return an atomic value of type xs:time by either converting it
437 to an \c xs:dateTime with an arbitrary date, or to an \c xs:string.
439 \section1 Using XQuery with Non-XML Data
441 Although the XQuery language was designed for querying XML, with
442 Qt XML Patterns one can use XQuery for querying any data that can
443 be modeled to look like XML. Non-XML data is modeled to look like
444 XML by loading it into a custom subclass of QAbstractXmlNodeModel,
445 where it is then presented to the Qt XML Patterns XQuery engine via
446 the same API the XQuery engine uses for querying XML.
448 When Qt XML Patterns loads and queries XML files and produces XML
449 output, it can always load the XML data into its default XML node
450 model, where it can be traversed efficiently. The XQuery below
451 traverses the product orders found in the XML file \e myOrders.xml
452 to find all the skin care product orders and output them ordered
455 \quotefile patternist/introAcneRemover.xq
457 Qt XML Patterns can be used out of the box to perform this
458 query, provided \e myOrders.xml actually contains well-formed XML. It
459 can be loaded directly into the default XML node model and
460 traversed. But suppose we want Qt XML Patterns to perform queries on
461 the hierarchical structure of the local file system. The default
462 XML node model in Qt XML Patterns is not suitable for navigating the
463 file system, because there is no XML file to load that contains a
464 description of it. Such an XML file, if it existed, might look
467 \quotefile patternist/introFileHierarchy.xml
469 The \l{File System Example}{File System Example} does exactly this.
471 There is no such file to load into the default XML node model, but
472 one can write a subclass of QAbstractXmlNodeModel to represent the
473 file system. This custom XML node model, once populated with all
474 the directory and file descriptors obtained directly from the
475 system, presents the complete file system hierarchy to the query
476 engine via the same API used by the default XML node model to
477 present the contents of an XML file. In other words, once the
478 custom XML node model is populated, it presents the file system to
479 the query engine as if a description of it had been loaded into
480 the default XML node model from an XML file like the one shown
483 Now we can write an XQuery to find all the XML files and parse
484 them to find the ones that don't contain well-formed XML.
486 \quotefromfile patternist/introNavigateFS.xq
490 Without Qt XML Patterns, there is no simple way to solve this kind
491 of problem. You might do it by writing a C++ program to traverse
492 the file system, sniff out all the XML files, and submit each one
493 to an XML parser to test that it contains valid XML. The C++ code
494 required to write that program will probably be more complex than
495 the C++ code required to subclass QAbstractXmlNodeModel, but even
496 if the two are comparable, your custom C++ program can be used
497 only for that one task, while your custom XML node model can be
498 used by any XQuery that must navigate the file system.
500 The general approach to using XQuery to perform queries on non-XML
501 data has been a three step process. In the first step, the data is
502 loaded into a non-XML data model. In the second step, the non-XML
503 data model is serialized as XML and output to XML (text) files. In
504 the final step, an XML tool loads the XML files into a second, XML
505 data model, where the XQueries can be performed. The development
506 cost of implementing this process is often high, and the three
507 step system that results is inefficient because the two data
508 models must be built and maintained separately.
510 With Qt XML Patterns, subclassing QAbstractXmlNodeModel eliminates
511 the transformation required to convert the non-XML data model to
512 the XML data model, because there is only ever one data model
513 required. The non-XML data model presents the non-XML data to the
514 query engine via the XML data model API. Also, since the query
515 engine uses the API to access the QAbstractXmlNodeModel, the data
516 model subclass can construct the elements, attributes and other
517 data on demand, responding to the query's specific requests. This
518 can greatly improve efficiency, because it means the entire model
519 might not have to be built. For example, in the file system model
520 above, it is not necessary to build an instance for a whole
521 XML file representing the whole file system. Instead nodes are
522 created on demand, which also likely is a small subset of the file
525 Examples of other places where XQuery could be used in
526 Qt XML Patterns to query non-XML data:
530 \li The internal representation for word processor documents
532 \li The set of dependencies for a software build system
534 \li The hierarchy (or graph) that links a set of HTML documents
537 \li The images and meta-data in an image collection
539 \li The set of D-Bus interfaces available in a system
541 \li A QObject hierarchy, as seen in the \l{QObject XML Model
542 Example} {QObject XML Model example}.
546 See the QAbstractXmlNodeModel documentation for information about
547 how to implement custom XML node models.
549 \section1 More on using Qt XML Patterns with non-XML Data
551 Subclassing QAbstractXmlNodeModel to let the query engine access
552 non-XML data by the same API it uses for XML is the feature that
553 enables Qt XML Patterns to query non-XML data with XQuery. It allows
554 XQuery to be used as a mapping layer between different non-XML
555 node models or between a non-XML node model and the built-in XML
556 node model. Once the subclass(es) of QAbstractXmlNodeModel have
557 been written, XQuery can be used to select a set of elements from
558 one node model, transform the selected elements, and then write
559 them out, either as XML using QXmlQuery::evaluateTo() and QXmlSerializer,
560 or as some other format using a subclass of QAbstractXmlReceiver.
562 Consider a word processor application that must import and export
563 data in several different formats. Rather than writing a lot of
564 C++ code to convert each input format to an intermediate form, and
565 more C++ code to convert the intermediate form back to each
566 output format, one can implement a solution based on Qt XML Patterns
567 that uses simple XQueries to transform each XML or non-XML format
568 (e.g. MathFormula.xml below) to the intermediate form (e.g. the
569 DocumentRepresentation node model class below), and more simple
570 XQueries to transform the intermediate form back to each XML or
573 \image patternist-wordProcessor.png
575 Because CSV files are not XML, a subclass of QAbstractXmlNodeModel
576 is used to present the CSV data to the XQuery engine as if it were
577 XML. What are not shown are the subclasses of QAbstractXmlReceiver
578 that would then send the selected elements into the
579 DocumentRepresentation node model, and the subclasses of
580 QAbstractXmlNodeModel that would ultimately write the output files
583 \section1 Security Considerations
585 \section2 Code Injection
587 XQuery is vulnerable to
588 \l{http://en.wikipedia.org/wiki/Code_injection} {code injection
589 attacks} in the same way as the SQL language. If an XQuery is
590 constructed by concatenating strings, and the strings come from
591 user input, the constructed XQuery could be malevolent. The best
592 way to prevent code injection attacks is to not construct XQueries
593 from user-written strings, but only accept user data input using
594 QVariant and variable bindings. See QXmlQuery::bindVariable().
597 \l{http://www.ibm.com/developerworks/xml/library/x-xpathinjection.html}
598 {Avoid the dangers of XPath injection}, by Robi Sen and
599 \l{http://www.packetstormsecurity.org/papers/bypass/Blind_XPath_Injection_20040518.pdf}
600 {Blind XPath Injection}, by Amit Klein, discuss the XQuery code
601 injection problem in more detail.
603 \section2 Denial of Service Attacks
605 Applications using Qt XML Patterns are subject to the same
606 limitations of software as other systems. Generally, these can not
607 be checked. This means Qt XML Patterns does not prevent rogue
608 queries from consuming too many resources. For example, a query
609 could take too much time to execute or try to transfer too much
610 data. A query could also do too much recursion, which could crash
611 the system. XQueries can do these things accidentally, but they
612 can also be done as deliberate denial of service attacks.
614 \section1 Features and Conformance
618 Qt XML Patterns aims at being a
619 \l{http://www.w3.org/TR/xquery/#id-xquery-conformance} {conformant
620 XQuery processor}. It adheres to
621 \l{http://www.w3.org/TR/xquery/#id-minimal-conformance} {Minimal
622 Conformance} and supports the
623 \l{http://www.w3.org/TR/xquery/#id-serialization-feature}
624 {Serialization Feature} and the
625 \l{http://www.w3.org/TR/xquery/#id-full-axis-feature} {Full Axis
626 Feature}. Qt XML Patterns currently passes 97% of the tests in the
627 \l{http://www.w3.org/XML/Query/test-suite} {XML Query Test Suite}.
628 Areas where conformance may be questionable and where behavior may
629 be changed in future releases include:
633 \li Some corner cases involving namespaces and element constructors
636 \li XPath is a subset of XQuery and the implementation of
637 Qt XML Patterns uses XPath 2.0 with XQuery 1.0.
641 The specifications discusses conformance further:
642 \l{http://www.w3.org/TR/xquery/}{XQuery 1.0: An XML Query
643 Language}. W3C's XQuery testing effort can be of interest as
644 well, \l{http://www.w3.org/XML/Query/test-suite/}{XML Query Test
647 Currently \c fn:collection() does not access any data set, and
648 there is no API for providing data through the collection. As a
649 result, evaluating \c fn:collection() returns the empty
650 sequence. We intend to provide functionality for this in a future
653 Only queries encoded in UTF-8 are supported.
657 Partial support for XSLT was introduced in Qt 4.5. Future
658 releases of Qt XML Patterns will aim to support these XSLT
662 \li Basic XSLT 2.0 processor
663 \li Serialization feature
664 \li Backwards Compatibility feature
667 For details, see \l{http://www.w3.org/TR/xslt20/#conformance}{XSL
668 Transformations (XSLT) Version 2.0, 21 Conformance}.
670 \note In this release, XSLT support is considered experimental.
672 Unsupported or partially supported XSLT features are documented
673 in the following table. The implementation of XSLT in Qt 4.5 can
674 be seen as XSLT 1.0 but with the data model of XPath 2.0 and
675 XSLT 2.0, and using the using the functionality of XPath 2.0 and
676 its accompanying function library. When Qt XML Patterns encounters
677 an unsupported or partially support feature, it will either report
678 a syntax error or silently continue, unless otherwise noted in the
681 The implementation currently passes 42% of W3C's XSLT test suite,
682 which focus on features introduced in XSLT 2.0.
689 \li \c xsl:key and \c fn:key()
700 \li The \c copy-namespaces and \c inherit-namespaces attributes
701 have no effect. For copied comments, attributes and
702 processing instructions, the copy has the same node
703 identity as the original.
707 \li The \c copy-namespaces attribute has no effect.
709 \li \c fn:format-number()
718 \li \c Tunnel Parameters
721 \li \c xsl:attribute-set
724 \li \c xsl:decimal-format
730 \li \c xsl:apply-imports
733 \li \c xsl:character-map
739 \li \c xsl:namespace-alias
745 \li \c xsl:output-character
748 \li \c xsl:preserve-space
751 \li \c xsl:result-document
755 \li Complex patterns or patterns with predicates have issues.
757 \li \c 2.0 Compatibility Mode
759 \li Stylesheets are interpreted as XSLT 2.0 stylesheets, even
760 if the \c version attribute is in the XSLT source is
761 1.0. In other words, the version attribute is ignored.
766 \li \c fn:current-group(), \c fn:grouping-key() and \c
771 \li \c xsl:analyze-string, \c xsl:matching-substring,
772 \c xsl:non-matching-substring, and \c fn:regex-group()
774 \li Date & Time formatting
775 \li \c fn:format-dateTime(), \c fn:format-date() and fn:format-time().
778 \li XPath Conformance
779 \li Since XPath is a subset of XSLT, its issues are in affect too.
782 The Qt XML Patterns implementation of the XPath Data Model does not
783 include entities (due to QXmlStreamReader not reporting them).
784 This means that functions \c unparsed-entity-uri() and \c
785 unparsed-entity-public-id() always return negatively.
789 Since XPath 2.0 is a subset of XQuery 1.0, XPath 2.0 is
790 supported. Areas where conformance may be questionable and,
791 consequently, where behavior may be changed in future releases
795 \li Regular expression support is currently not conformant
796 but follows Qt's QRegExp standard syntax.
798 \li Operators for \c xs:time, \c xs:date, and \c xs:dateTime
801 \li Formatting of very large or very small \c xs:double, \c
802 xs:float, and \c xs:decimal values may be incorrect.
807 Processing of XML files supports \c xml:id. This allows elements
808 that have an attribute named \c xml:id to be looked up efficiently
809 with the \c fn:id() function. See
810 \l{http://www.w3.org/TR/xml-id/}{xml:id Version 1.0} for details.
812 \section2 XML Schema 1.0
814 There are two ways Qt XML Patterns can be used to validate schemas:
815 You can use the C++ API in your Qt application using the classes
816 QXmlSchema and QXmlSchemaValidator, or you can use the command line
817 utility named xmlpatternsvalidator (located in the "bin" directory
820 The Qt XML Patterns implementation of XML Schema validation supports
821 the schema specification version 1.0 in large parts. Known problems
822 of the implementation and areas where conformancy may be questionable
826 \li Large \c minOccurs or \c maxOccurs values or deeply nested ones
827 require huge amount of memory which might cause the system to freeze.
828 Such a schema should be rewritten to use \c unbounded as value instead
829 of large numbers. This restriction will hopefully be fixed in a later release.
830 \li Comparison of really small or large floating point values might lead to
831 wrong results in some cases. However such numbers should not be relevant
832 for day-to-day usage.
833 \li Regular expression support is currently not conformant but follows
834 Qt's QRegExp standard syntax.
835 \li Identity constraint checks can not use the values of default or fixed
836 attribute definitions.
839 \section2 Resource Loading
841 When Qt XML Patterns loads an XML resource, e.g., using the
842 \c fn:doc() function, the following schemes are supported:
854 \li The bytes are encoded in the URI itself. e.g., \c
855 data:application/xml,%3Ce%2F%3E is \c <e/>.
859 \li Resources retrieved via FTP.
862 \li Resources retrieved via HTTP.
865 \li Resources retrieved via HTTPS. This will succeed if no SSL
866 errors are encountered.
869 \li Qt Resource files. Expressing it as an empty scheme, :/...,
876 XML 1.0 and XML Namespaces 1.0 are supported, as opposed to the
877 1.1 versions. When a strings is passed to a query as a QString,
878 the characters must be XML 1.0 characters. Otherwise, the behavior
879 is undefined. This is not checked.
881 URIs are first passed to QAbstractUriResolver. Check
882 QXmlQuery::setUriResolver() for possible rewrites.
886 \namespace QPatternist
887 \brief The QPatternist namespace contains classes and functions required by the Qt XML Patterns module.