book

XQuery

Name: XQuery
Author: Priscilla Walmsley
ISBN: 9780596006341

by Priscilla Walmsley

March 2007

Intermediate to advanced

512 pages

21h 15m

English

O'Reilly Media, Inc.

Read now

Unlock full access

XQuery
A Note Regarding Supplemental Files
Preface
Contents of This Book
Reading the Syntax Diagrams
Conventions Used in This Book
Using Code Examples
Useful Functions
We'd Like to Hear from You
Acknowledgments
1. Introduction to XQuery
1.1. What Is XQuery?1.1.1. Capabilities of XQuery1.1.2. Uses for XQuery1.1.3. Processing Scenarios

1.2. Easing into XQuery
1.3. Path Expressions
1.4. FLWORs
1.5. Adding XML Elements and Attributes
1.5.1. Adding Elements1.5.2. Adding Attributes
1.6. Functions
1.7. Joins
1.8. Aggregating and Grouping Values
2. XQuery Foundations
2.1. The Design of the XQuery Language
2.2. XQuery in Context
2.2.1. XQuery and XPath2.2.2. XQuery Versus XSLT2.2.3. XQuery Versus SQL2.2.4. XQuery and XML Schema
2.3. Processing Queries
2.3.1. XML Input Documents2.3.2. The Query2.3.3. The Context2.3.4. The Query Processor2.3.5. The Results of the Query
2.4. The XQuery Data Model
2.4.1. Nodes2.4.1.1. Node kinds2.4.1.2. The node hierarchy2.4.1.3. The node family2.4.1.4. Roots, documents, and elements2.4.1.5. Node identity and name2.4.1.6. String and typed values of nodes2.4.2. Atomic Values2.4.3. Sequences
2.5. Types
2.6. Namespaces
3. Expressions: XQuery Building Blocks
3.1. Categories of Expressions
3.2. Keywords and Names
3.3. Whitespace in Queries
3.4. Literals
3.5. Variables
3.6. Function Calls
3.7. Comments
3.8. Evaluation Order and Parentheses
3.9. Comparison Expressions
3.9.1. General Comparisons3.9.1.1. General comparisons on multi-item sequences3.9.1.2. General comparisons and types3.9.2. Value Comparisons3.9.3. Node Comparisons
3.10. Conditional (if-then-else) Expressions
3.10.1. Conditional Expressions and Effective Boolean Values3.10.2. Nesting Conditional Expressions
3.11. Logical (and/or) Expressions
3.11.1. Evaluation Order of Logical Expressions3.11.2. Negating a Boolean Value
4. Navigating Input Documents Using Paths
4.1. Path Expressions4.1.1. Path Expressions and Context4.1.1.1. Steps and changing context4.1.2. Steps4.1.3. Axes4.1.4. Node Tests4.1.4.1. Node name tests4.1.4.2. Node name tests and namespaces4.1.4.3. Node name tests and wildcards4.1.4.4. Node kind tests4.1.5. Abbreviated Syntax4.1.6. Other Expressions As Steps
4.2. Predicates
4.2.1. Comparisons in Predicates4.2.2. Using Positions in Predicates4.2.2.1. Understanding positional predicates4.2.2.2. The position and last functions4.2.2.3. Positional predicates and reverse axes4.2.3. Using Multiple Predicates4.2.4. More Complex Predicates
4.3. Dynamic Paths
4.4. Input Documents
4.4.1. Accessing a Single Document4.4.2. Accessing a Collection4.4.3. Setting the Context Node Outside the Query4.4.4. Using Variables
4.5. A Closer Look at Context
4.5.1. Working with the Context Node4.5.2. Accessing the Root
5. Adding Elements and Attributes to Results
5.1. Including Elements and Attributes from the Input Document
5.2. Direct Element Constructors
5.2.1. Containing Literal Characters5.2.2. Containing Other Element Constructors5.2.3. Containing Enclosed Expressions5.2.3.1. Enclosed expressions that evaluate to elements5.2.3.2. Enclosed expressions that evaluate to attributes5.2.3.3. Enclosed expressions that evaluate to atomic values5.2.3.4. Enclosed expressions with multiple subexpressions5.2.4. Specifying Attributes Directly5.2.5. Declaring Namespaces in Direct Constructors5.2.6. Use Case: Modifying an Element from the Input Document5.2.7. Direct Element Constructors and Whitespace5.2.7.1. Boundary whitespace5.2.7.2. The boundary-space declaration5.2.7.3. Forcing boundary whitespace preservation
5.3. Computed Constructors
5.3.1. Computed Element Constructors5.3.1.1. Names of computed element constructors5.3.1.2. Content of computed element constructors5.3.2. Computed Attribute Constructors5.3.3. Use Case: Turning Content to Markup
6. Selecting and Joining Using FLWORs
6.1. Selecting with Path Expressions
6.2. FLWOR Expressions
6.2.1. The for Clause6.2.1.1. Range expressions6.2.1.2. Multiple for clauses6.2.2. The let Clause6.2.3. The where Clause6.2.4. The return Clause6.2.5. The Scope of Variables
6.3. Quantified Expressions
6.3.1. Binding Multiple Variables
6.4. Selecting Distinct Values
6.5. Joins
6.5.1. Three-Way Joins6.5.2. Outer Joins6.5.3. Joins and Types
7. Sorting and Grouping
7.1. Sorting in XQuery7.1.1. The order by Clause7.1.1.1. Using multiple ordering specifications7.1.1.2. Sorting and types7.1.1.3. Order modifiers7.1.1.4. Empty order7.1.1.5. Stable ordering7.1.1.6. More complex order specifications7.1.2. Document Order7.1.2.1. Document order defined7.1.2.2. Sorting in document order7.1.2.3. Inadvertent resorting in document order7.1.3. Order Comparisons7.1.4. Reversing the Order7.1.5. Indicating That Order Is Not Significant7.1.5.1. The unordered function7.1.5.2. The unordered expression7.1.5.3. The ordering mode declaration
7.2. Grouping
7.3. Aggregating Values
7.3.1. Ignoring "Missing" Values7.3.2. Counting "Missing" Values7.3.3. Aggregating on Multiple Values7.3.4. Constraining and Sorting on Aggregated Values
8. Functions
8.1. Built-in Versus User-Defined Functions
8.2. Calling Functions
8.2.1. Function Names8.2.2. Function Signatures8.2.3. Argument Lists8.2.3.1. Argument lists and the empty sequence8.2.3.2. Argument lists and sequences8.2.4. Sequence Types
8.3. User-Defined Functions
8.3.1. Why Define Your Own Functions?8.3.2. Function Declarations8.3.3. The Function Body8.3.4. The Function Name8.3.5. The Parameter List8.3.5.1. Accepting arguments that are nodes versus atomic values8.3.5.2. Accepting arguments that are the empty sequence8.3.6. Functions and Context8.3.7. Recursive Functions
9. Advanced Queries
9.1. Copying Input Elements with Modifications9.1.1. Adding Attributes to an Element9.1.2. Removing Attributes from an Element9.1.3. Removing Attributes from All Descendants9.1.4. Removing Child Elements9.1.5. Changing Names
9.2. Working with Positions and Sequence Numbers
9.2.1. Adding Sequence Numbers to Results9.2.2. Testing for the Last Item
9.3. Combining Results
9.3.1. Sequence Constructors9.3.2. The union Expression9.3.3. The intersect Expression9.3.4. The except Expression
9.4. Using Intermediate XML Documents
9.4.1. Creating Lookup Tables9.4.2. Reducing Complexity
10. Namespaces and XQuery
10.1. XML Namespaces10.1.1. Namespace URIs10.1.2. Declaring Namespaces10.1.3. Default Namespace Declarations10.1.4. Namespaces and Attributes10.1.5. Namespace Declarations and Scope
10.2. Namespaces and XQuery
10.3. Namespace Declarations in Queries
10.3.1. Predeclared Namespaces10.3.2. Prolog Namespace Declarations10.3.2.1. Default namespace declarations in the prolog10.3.2.2. The default function namespace declaration10.3.2.3. Other prolog namespace declarations10.3.3. Namespace Declarations in Element Constructors10.3.4. The Impact and Scope of Namespace Declarations10.3.4.1. Scope of namespace declarations10.3.4.2. Names affected by namespace declarations10.3.4.3. Namespace declarations and input elements
10.4. Controlling Namespace Declarations in Your Results
10.4.1. In-Scope Versus Statically Known Namespaces10.4.2. Controlling the Copying of Namespace Declarations
11. A Closer Look at Types
11.1. The XQuery Type System11.1.1. Advantages of a Strong Type System11.1.2. Do You Need to Care About Types?
11.2. The Built-in Types
11.3. Types, Nodes, and Atomic Values
11.3.1. Nodes and Types11.3.2. Atomic Values and Types
11.4. Type Checking in XQuery
11.4.1. The Static Analysis Phase11.4.2. The Dynamic Evaluation Phase
11.5. Automatic Type Conversions
11.5.1. Subtype Substitution11.5.2. Type Promotion11.5.3. Casting of Untyped Values11.5.4. Atomization11.5.5. Effective Boolean Value11.5.6. Function Conversion Rules
11.6. Sequence Types
11.6.1. Occurrence Indicators11.6.2. Generic Sequence Types11.6.3. Atomic Type Names As Sequence Types11.6.4. Element and Attribute Tests11.6.5. Sequence Type Matching11.6.6. The "instance of" Expression
11.7. Constructors and Casting
11.7.1. Constructors11.7.2. The Cast Expression11.7.3. The Castable Expression11.7.4. Casting Rules11.7.4.1. Casting among the primitive types11.7.4.2. Casting to xs:string or xs:untypedAtomic11.7.4.3. Casting to xs:string or xs:untypedAtomic11.7.4.4. Casting among derived types
12. Queries, Prologs, and Modules
12.1. Structure of a Query: Prolog and Body12.1.1. Prolog Declarations12.1.2. The Version Declaration
12.2. Assembling Queries from Multiple Modules
12.2.1. Library Modules12.2.2. Importing a Library Module12.2.2.1. Multiple module imports12.2.2.2. The behavior of a module import
12.3. Variable Declarations
12.3.1. Variable Declaration Syntax12.3.2. The Scope of Variables12.3.3. Variable Names12.3.4. Initializing Expressions12.3.5. External Variables
12.4. Declaring External Functions
13. Using Schemas with XQuery
13.1. What Is a Schema?
13.2. Why Use Schemas with Queries?
13.3. W3C XML Schema: A Brief Overview
13.3.1. Element and Attribute Declarations13.3.2. Types13.3.2.1. Simple and complex types13.3.2.2. User-defined types13.3.2.3. List types13.3.3. Namespaces and XML Schema
13.4. In-Scope Schema Definitions
13.4.1. Where Do In-Scope Schema Definitions Come from?13.4.2. Schema Imports13.4.2.1. Importing a schema with no target namespace13.4.2.2. Importing multiple schemas with the same target namespace13.4.2.3. Schema imports and library modules
13.5. Schema Validation and Type Assignment
13.5.1. The Validate Expression13.5.2. Validation Mode13.5.3. Assigning Type Annotations to Nodes13.5.4. Nodes and Typed Values13.5.5. Types and Newly Constructed Elements and Attributes
13.6. Sequence Types and Schemas
14. Static Typing
14.1. What Is Static Typing?14.1.1. Obvious Static Type Errors14.1.2. Static Typing and Schemas14.1.3. Raising "False" Errors14.1.4. Static Typing Expressions and Constructs
14.2. The Typeswitch Expression
14.3. The Treat Expression
14.4. Type Declarations
14.4.1. Type Declarations in FLWORs14.4.2. Type Declarations in Quantified Expressions14.4.3. Type Declarations in Global Variable Declarations
14.5. The zero-or-one, one-or-more, and exactly-one Functions
15. Principles of Query Design
15.1. Query Design Goals
15.2. Clarity
15.2.1. Improving the Layout15.2.2. Choosing Names15.2.3. Using Comments for Documentation
15.3. Modularity
15.4. Robustness
15.4.1. Handling Data Variations15.4.2. Handling Missing Values15.4.2.1. Absent values15.4.2.2. Empty and nil values15.4.2.3. Default "missing" values
15.5. Error Handling
15.5.1. Avoiding Dynamic Errors15.5.2. The error and trace Functions
15.6. Performance
15.6.1. Avoid Reevaluating the Same or Similar Expressions15.6.2. Avoid Unnecessary Sorting15.6.3. Avoid Expensive Path Expressions15.6.4. Use Predicates Instead of where Clauses
16. Working with Numbers
16.1. The Numeric Types16.1.1. The xs:decimal Type16.1.2. The xs:integer Type16.1.3. The xs:float and xs:double Types
16.2. Constructing Numeric Values
16.2.1. The number Function16.2.2. Numeric Type Promotion
16.3. Comparing Numeric Values
16.4. Arithmetic Operations
16.4.1. Arithmetic Operations on Multiple Values16.4.2. Arithmetic Operations and Types16.4.3. Precedence of Arithmetic Operators16.4.4. Addition, Subtraction, and Multiplication16.4.5. Division16.4.6. Modulus (Remainder)
16.5. Functions on Numbers
17. Working with Strings
17.1. The xs:string Type
17.2. Constructing Strings
17.2.1. String Literals17.2.2. The xs:string Constructor and the string Function
17.3. Comparing Strings
17.3.1. Comparing Entire Strings17.3.2. Determining Whether a String Contains Another String17.3.3. Matching a String to a Pattern
17.4. Substrings
17.5. Finding the Length of a String
17.6. Concatenating and Splitting Strings
17.6.1. Concatenating Strings17.6.2. Splitting Strings Apart17.6.3. Converting Between Code Points and Strings
17.7. Manipulating Strings
17.7.1. Converting Between Uppercase and Lowercase17.7.2. Replacing Individual Characters in Strings17.7.3. Replacing Substrings That Match a Pattern
17.8. Whitespace and Strings
17.8.1. Normalizing Whitespace
17.9. Internationalization Considerations
17.9.1. Collations17.9.2. Unicode Normalization17.9.3. Determining the Language of an Element
18. Regular Expressions
18.1. The Structure of a Regular Expression18.1.1. Atoms18.1.2. Quantifiers18.1.3. Parenthesized Sub-Expressions and Branches
18.2. Representing Individual Characters
18.3. Representing Any Character
18.4. Representing Groups of Characters
18.4.1. Multi-Character Escapes18.4.2. Category Escapes18.4.3. Block Escapes
18.5. Character Class Expressions
18.5.1. Single Characters and Ranges18.5.2. Subtraction from a Range18.5.3. Negative Character Class Expressions18.5.4. Escaping Rules for Character Class Expressions
18.6. Reluctant Quantifiers
18.7. Anchors
18.7.1. Anchors and Multi-Line Mode
18.8. Back-References
18.9. Using Flags
18.10. Using Sub-Expressions with Replacement Variables
19. Working with Dates, Times, and Durations
19.1. The Date and Time Types19.1.1. Constructing and Casting Dates and Times19.1.2. Time Zones19.1.2.1. Explicit versus implicit time zones19.1.2.2. Adjusting time zones19.1.2.3. Finding the time zone of a value19.1.3. Comparing Dates and Times
19.2. The Duration Types
19.2.1. The yearMonthDuration and dayTimeDuration Types19.2.2. Comparing Durations
19.3. Extracting Components of Dates, Times, and Durations
19.4. Using Arithmetic Operators on Dates, Times, and Durations
19.4.1. Subtracting Dates and Times19.4.2. Adding and Subtracting Durations from Dates and Times19.4.3. Adding and Subtracting Two Durations19.4.4. Multiplying and Dividing Durations by Numbers19.4.5. Dividing Durations by Durations
19.5. The Date Component Types
20. Working with Qualified Names, URIs, and IDs
20.1. Working with Qualified Names20.1.1. Retrieving Node Names20.1.2. Constructing Qualified Names20.1.3. Other Name-Related Functions
20.2. Working with URIs
20.2.1. Base and Relative URIs20.2.1.1. Using the xml:base attribute20.2.1.2. Finding the base URI of a node20.2.1.3. Resolving URIs20.2.1.4. The base URI of the static context20.2.2. Documents and URIs20.2.2.1. Finding the URI of a document20.2.2.2. Opening a document from a dynamic value20.2.3. Escaping URIs
20.3. Working with IDs
20.3.1. Joining IDs and IDREFs20.3.2. Constructing IDs
21. Working with Other XML Components
21.1. XML Comments21.1.1. XML Comments and the Data Model21.1.2. Querying Comments21.1.3. Comments and Sequence Types21.1.4. Constructing Comments
21.2. Processing Instructions
21.2.1. Processing Instructions and the Data Model21.2.2. Querying Processing Instructions21.2.3. Processing Instructions and Sequence Types21.2.4. Constructing Processing Instructions
21.3. Documents
21.3.1. Document Nodes and the Data Model21.3.2. Document Nodes and Sequence Types21.3.3. Constructing Document Nodes
21.4. Text Nodes
21.4.1. Text Nodes and the Data Model21.4.2. Querying Text Nodes21.4.3. Text Nodes and Sequence Types21.4.4. Why Work with Text Nodes?21.4.5. Constructing Text Nodes
21.5. XML Entity and Character References
21.6. CDATA Sections
22. Additional XQuery-Related Standards
22.1. Serialization
22.2. XQueryX
22.3. XQuery Update Facility
22.4. Full-Text Search
22.5. XQuery API for Java (XQJ)
23. Implementation-Specific Features
23.1. Conformance
23.2. XML Version Support
23.3. Setting the Query Context
23.4. Option Declarations and Extension Expressions
23.4.1. The Option Declaration23.4.2. Extension Expressions
23.5. Specifying Serialization Parameters
24. XQuery for SQL Users
24.1. Relational Versus XML Data Models
24.2. Comparing SQL Syntax with XQuery Syntax
24.2.1. A Simple Query24.2.2. Conditions and Operators24.2.2.1. Comparisons24.2.2.2. Arithmetic and string operators24.2.2.3. Boolean operators24.2.3. Functions24.2.4. Selecting Distinct Values24.2.5. Working with Multiple Tables and Subqueries24.2.5.1. Subselects24.2.5.2. Combining queries using set operators24.2.6. Grouping
24.3. Combining SQL and XQuery
24.3.1. Combining Structured and Semistructured Data24.3.2. Flexible Data Structures
24.4. SQL/XML
25. XQuery for XSLT Users
25.1. XQuery and XPath
25.2. XQuery Versus XSLT
25.2.1. Shared Components25.2.2. Equivalent Components25.2.3. Differences25.2.3.1. Paradigm differences: push versus pull25.2.3.2. Optimization for particular use cases25.2.3.3. Convenient features of XSLT
25.3. Differences Between XQuery 1.0/XPath 2.0 and XPath 1.0
25.3.1. Data Model25.3.2. New Expressions25.3.3. Path Expressions25.3.4. Function Conversion Rules25.3.5. Arithmetic and Comparison Expressions25.3.6. Built-in Functions
A. Built-in Function Reference
B. Built-in Types
B.1. xs:anyAtomicType
B.2. xs:anyType
B.3. xs:anyURI
B.3.1. Casting and Comparing xs:anyURI Values
B.4. xs:base64Binary
B.5. xs:boolean
B.5.1. Constructing xs:boolean ValuesB.5.2. Casting xs:boolean Values
B.6. xs:byte
B.7. xs:date
B.8. xs:dateTime
B.9. xs:dayTimeDuration
B.10. xs:decimal
B.10.1. Casting xs:decimal Values
B.11. xs:double
B.11.1. Casting xs:double Values
B.12. xs:duration
B.13. xs:ENTITIES
B.14. xs:ENTITY
B.15. xs:float
B.15.1. Casting xs:float Values
B.16. xs:gDay
B.17. xs:gMonth
B.18. xs:gMonthDay
B.19. xs:gYear
B.20. xs:gYearMonth
B.21. xs:hexBinary
B.21.1. Casting and Comparing xs:hexBinary Values
B.22. xs:ID
B.23. xs:IDREF
B.24. xs:IDREFS
B.25. xs:int
B.26. xs:integer
B.26.1. Casting xs:integer Values
B.27. xs:language
B.28. xs:long
B.29. xs:Name
B.30. xs:NCName
B.31. xs:negativeInteger
B.32. xs:NMTOKEN
B.33. xs:NMTOKENS
B.34. xs:nonNegativeInteger
B.35. xs:nonPositiveInteger
B.36. xs:normalizedString
B.37. xs:NOTATION
B.38. xs:positiveInteger
B.39. xs:QName
B.40. xs:short
B.41. xs:string
B.42. xs:time
B.43. xs:token
B.44. xs:unsignedByte
B.45. xs:unsignedInt
B.46. xs:unsignedLong
B.47. xs:unsignedShort
B.48. xs:untyped
B.49. xs:untypedAtomic
B.50. xs:yearMonthDuration
C. Error Summary
C.1. FOAR0001
C.2. FOAR0002
C.3. FOCA0001
C.4. FOCA0002
C.5. FOCA0003
C.6. FOCA0005
C.7. FOCA0006
C.8. FOCH0001
C.9. FOCH0002
C.10. FOCH0003
C.11. FOCH0004
C.12. FODC0001
C.13. FODC0002
C.14. FODC0003
C.15. FODC0004
C.16. FODC0005
C.17. FODT0001
C.18. FODT0002
C.19. FODT0003
C.20. FOER0000
C.21. FONS0004
C.22. FONS0005
C.23. FORG0001
C.24. FORG0002
C.25. FORG0003
C.26. FORG0004
C.27. FORG0005
C.28. FORG0006
C.29. FORG0008
C.30. FORG0009
C.31. FORX0001
C.32. FORX0002
C.33. FORX0003
C.34. FORX0004
C.35. FOTY0012
C.36. SENR0001
C.37. SEPM0004
C.38. SEPM0009
C.39. SEPM0010
C.40. SEPM0016
C.41. SERE0003
C.42. SERE0005
C.43. SERE0006
C.44. SERE0008
C.45. SERE0012
C.46. SERE0014
C.47. SERE0015
C.48. SESU0007
C.49. SESU0011
C.50. SESU0013
C.51. XPDY0002
C.52. XPDY0050
C.53. XPST0001
C.54. XPST0003
C.55. XPST0005
C.56. XPST0008
C.57. XPST0010
C.58. XPST0017
C.59. XPST0051
C.60. XPST0080
C.61. XPST0081
C.62. XPTY0004
C.63. XPTY0018
C.64. XPTY0019
C.65. XPTY0020
C.66. XQDY0025
C.67. XQDY0026
C.68. XQDY0027
C.69. XQDY0041
C.70. XQDY0044
C.71. XQDY0061
C.72. XQDY0064
C.73. XQDY0072
C.74. XQDY0074
C.75. XQDY0084
C.76. XQDY0091
C.77. XQDY0092
C.78. XQST0009
C.79. XQST0012
C.80. XQST0013
C.81. XQST0016
C.82. XQST0022
C.83. XQST0031
C.84. XQST0032
C.85. XQST0033
C.86. XQST0034
C.87. XQST0035
C.88. XQST0036
C.89. XQST0038
C.90. XQST0039
C.91. XQST0040
C.92. XQST0045
C.93. XQST0046
C.94. XQST0047
C.95. XQST0048
C.96. XQST0049
C.97. XQST0054
C.98. XQST0055
C.99. XQST0057
C.100. XQST0058
C.101. XQST0059
C.102. XQST0060
C.103. XQST0065
C.104. XQST0066
C.105. XQST0067
C.106. XQST0068
C.107. XQST0069
C.108. XQST0070
C.109. XQST0071
C.110. XQST0073
C.111. XQST0075
C.112. XQST0076
C.113. XQST0079
C.114. XQST0085
C.115. XQST0087
C.116. XQST0088
C.117. XQST0089
C.118. XQST0090
C.119. XQST0093
C.120. XQTY0024
C.121. XQTY0030
C.122. XQTY0086
Index
Index
Colophon

Content preview from XQuery

In-Scope Schema Definitions

In any module, there is a set of in-scope schema definitions (ISSDs) that can be referenced within the query. This includes type definitions, element declarations and attribute declarations. They can describe the input documents, the result XML, or both. You may want to reference schema definitions for a number of reasons, such as:

To write functions that only accept values of a certain user-defined type. For example, a function that queries sleeve length might accept only elements of type ShirtType.
To validate a node that you constructed in your query. For example, you used constructors to create a product element and its children, and you want to ensure that it is valid according to ProductType.
To determine whether a value is an instance of a particular user-defined type in order to decide how to process it. For example, if the size value is an instance of ShirtSizeType, you want to call one function, whereas if it is a value of HatSizeType, you want to call a different function.
You want to perform static type analysis and you want the schema definitions to be taken into account.

If you don't need to do any of these things, you are not required to include your schemas in the in-scope schema definitions. This is true even if your input document was validated against a schema.

Where Do In-Scope Schema Definitions Come from?

Definitions for the built-in types are automatically included in the ISSD. A processor may include additional schema declarations and ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0596006349Errata

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

XQuery

by Priscilla Walmsley

In-Scope Schema Definitions

Where Do In-Scope Schema Definitions Come from?

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

More than 5,000 organizations count on O’Reilly

Julian F.

Addison B.

Amir M.

Mark W.

You might also like

XSLT

XPath and XPointer

XQuery Kick Start

MarkLogic Cookbook

Publisher Resources