A
- abs (absolute value) function, Functions on Numbers
- absent values, Handling Missing Values
- absolute URIs, Working with URIs
- addition, Arithmetic Operations, Precedence of Arithmetic Operators, Precedence of Arithmetic Operators, Adding and Subtracting Durations from Dates and Times, Adding and Subtracting Two Durations, Arithmetic and string operators
- + operator, Arithmetic Operations
- durations, Adding and Subtracting Two Durations
- durations to dates and times, Adding and Subtracting Durations from Dates and Times
- precedence of arithmetic operators, Precedence of Arithmetic Operators
- SQL and XQuery operators, Arithmetic and string operators
- adjust-time-to-timezone function, Finding the time zone of a value
- aggregating values, Aggregating and Grouping Values, Aggregating Values, Ignoring "Missing" Values, Counting "Missing" Values, Counting "Missing" Values, Constraining and Sorting on Aggregated Values
- constraining and sorting on aggregated values, Constraining and Sorting on Aggregated Values
- counting missing values, Counting "Missing" Values
- ignoring missing values, Ignoring "Missing" Values
- on multiple values, Counting "Missing" Values
- aggregation functions, Sequences, Functions on Numbers
- & (ampersand), Containing Literal Characters, The xs:string Constructor and the string Function, Finding the URI of a document, XML Entity and Character References, Full-Text Search
- && (and) full text operator, Full-Text Search
- entity reference (&), XML Entity and Character References
- escaping in element constructor content, Containing Literal Characters
- escaping in string literals, The xs:string Constructor and the string Function
- separator character in URIs, Finding the URI of a document
- analysis (compile) time, What Is Static Typing?
- ancestor axis, Node Tests, Avoid Expensive Path Expressions, Conformance
- in path expressions, Avoid Expensive Path Expressions
- ancestor-or-self axis, Avoid Expensive Path Expressions, Conformance
- in path expressions, Avoid Expensive Path Expressions
- ancestors (nodes), Roots, documents, and elements
- anchors (in regular expressions), Anchors, Anchors and Multi-Line Mode, Using Flags
- multi-line mode and, Anchors and Multi-Line Mode, Using Flags
- and operator, Logical (and/or) Expressions, Arithmetic and string operators
- SQL and XQuery, Arithmetic and string operators
- < > (angle brackets), Function Calls, Evaluation Order and Parentheses, Evaluation Order and Parentheses, Evaluation Order and Parentheses, Evaluation Order and Parentheses, Reversing the Order, Comparing Numeric Values, Comparing Numeric Values, Comparing Numeric Values, Comparing Numeric Values, Comparing Entire Strings, Representing Any Character, Finding the time zone of a value, Finding the time zone of a value, Comparing Dates and Times, Comparing Dates and Times, Extracting Components of Dates, Times, and Durations, Extracting Components of Dates, Times, and Durations, Processing Instructions and Sequence Types, XML Entity and Character References, XML Entity and Character References, CDATA Sections, Comparisons, Comparisons, Comparisons, Comparisons
- < (less than) operator, Evaluation Order and Parentheses, Comparing Numeric Values, Comparing Entire Strings, Representing Any Character, Comparing Dates and Times, Extracting Components of Dates, Times, and Durations, XML Entity and Character References, Comparisons
- comparing dates and times, Comparing Dates and Times
- comparing durations, Extracting Components of Dates, Times, and Durations
- comparing numeric values, Comparing Numeric Values
- comparing strings, Comparing Entire Strings
- entity reference (<), Representing Any Character, XML Entity and Character References
- SQL and XQuery, Comparisons
- <!-- -->, XML comment delimiters, Function Calls
- <![CDATA[ and ]]> CDATA section delimiter, CDATA Sections
- << and >> operators, comparing nodes by relative position in document order, Reversing the Order
- <= (less than or equal to) operator, Evaluation Order and Parentheses, Comparing Numeric Values, Finding the time zone of a value, Comparisons
- comparing dates and times, Finding the time zone of a value
- comparing numeric values, Comparing Numeric Values
- SQL and XQuery, Comparisons
- <? ?>, in processing instruction constructors, Processing Instructions and Sequence Types
- > (greater than) operator, Evaluation Order and Parentheses, Comparing Numeric Values, Comparing Dates and Times, Extracting Components of Dates, Times, and Durations, XML Entity and Character References, Comparisons
- comparing dates and times, Comparing Dates and Times
- comparing durations, Extracting Components of Dates, Times, and Durations
- comparing numeric values, Comparing Numeric Values
- entity reference (>), XML Entity and Character References
- SQL and XQuery, Comparisons
- >= (greater than or equal to) operator, Evaluation Order and Parentheses, Comparing Numeric Values, Finding the time zone of a value, Comparisons
- comparing dates and times, Finding the time zone of a value
- comparing numeric values, Comparing Numeric Values
- SQL and XQuery, Comparisons
- ' (apostrophe), entity reference ('), XML Entity and Character References
- argument lists (functions), Argument lists and sequences
- sequences and, Argument lists and sequences
- arguments (function), User-Defined Functions, Accepting arguments that are nodes versus atomic values, Accepting arguments that are nodes versus atomic values
- conversion to expected type, User-Defined Functions
- empty sequence as argument, Accepting arguments that are nodes versus atomic values
- nodes vs. atomic values, Accepting arguments that are nodes versus atomic values
- arithmetic operations, Keywords and Names, Numeric Type Promotion, Arithmetic Operations, Arithmetic Operations on Multiple Values, Division, Modulus (Remainder), Using Arithmetic Operators on Dates, Times, and Durations, Arithmetic and string operators, Function Conversion Rules
- division, Division
- expressions, Keywords and Names
- modulus (remainder), Modulus (Remainder)
- numeric type promotion in expressions, Numeric Type Promotion
- on dates, times, and durations, Using Arithmetic Operators on Dates, Times, and Durations
- on multiple numeric values, Arithmetic Operations on Multiple Values
- SQL and XQuery, Arithmetic and string operators
- XQuery 1.0 and XPath 1.0 and 2.0, Function Conversion Rules
- ascending or descending order, Order modifiers
- assertions, type, Type Declarations
- * (asterisk), FLWORs, Path Expressions, Node name tests and namespaces, User-Defined Functions, Accepting arguments that are nodes versus atomic values, Sequence Types, Sequence Types, Occurrence Indicators, The Castable Expression, Arithmetic Operations, Parenthesized Sub-Expressions and Branches, Representing Any Character, Anchors, Dividing Durations by Durations
- *? (reluctant quantifier), Anchors
- escaping in regular expressions, Representing Any Character
- multiplication operator, Arithmetic Operations, Dividing Durations by Durations
- multiplying durations by numbers, Dividing Durations by Durations
- occurrence indicator, zero, one, or many items, User-Defined Functions, Accepting arguments that are nodes versus atomic values, Sequence Types, Sequence Types, Occurrence Indicators, The Castable Expression
- cast expression and, The Castable Expression
- return type of function, Sequence Types
- quantifier, zero, one, or many occurrences, Parenthesized Sub-Expressions and Branches
- wildcard in path expressions, FLWORs, Path Expressions, Node name tests and namespaces
- at keyword, Adding Sequence Numbers to Results, Multiple module imports
- namespace prefix mapping in module import, Multiple module imports
- @ (at sign), Path Expressions, Other Expressions As Steps, Removing Attributes from an Element, Finding the URI of a document
- @*, copying attributes from an element, Removing Attributes from an Element
- abbreviation for attribute axis, Other Expressions As Steps
- returning attributes in path expressions, Path Expressions
- separator character in URIs, Finding the URI of a document
- atomic types, The Built-in Types, The Built-in Types, Atomic Type Names As Sequence Types
- as sequence types, Atomic Type Names As Sequence Types
- built into XQuery, The Built-in Types, The Built-in Types
- hierarchy, The Built-in Types
- atomic values, Atomic Values, General Comparisons, Predicates, Enclosed expressions that evaluate to attributes, User-Defined Functions, Accepting arguments that are nodes versus atomic values, Types, Nodes, and Atomic Values, Constructors and Casting, Casting among the primitive types, Casting among the primitive types, xs:untyped
- casting any type to xs:string or xs:untypedAtomic, Casting among the primitive types
- casting between specific types, Casting among the primitive types
- comparing, General Comparisons
- constructing with given types, Constructors and Casting
- enclosed expressions in direct element constructors evaluating to, Enclosed expressions that evaluate to attributes
- nodes vs. in function arguments, Accepting arguments that are nodes versus atomic values
- returned by last step in a path, Predicates
- sequence types for function parameters, User-Defined Functions
- types, Types, Nodes, and Atomic Values
- untyped, xs:untyped
- atomization, Atomization, Function Conversion Rules
- function conversion rules, Function Conversion Rules
- atoms (regular expressions), The Structure of a Regular Expression
- attribute axis, Steps
- attribute nodes, Nodes
- attribute( ) kind test, Element and Attribute Tests, Sequence Types and Schemas
- attributes, Path Expressions, The node hierarchy, Node identity and name, Node identity and name, Atomic Values, Namespaces, Including Elements and Attributes from the Input Document, Enclosed expressions that evaluate to attributes, Specifying Attributes Directly, Computed Attribute Constructors, Declaring Namespaces, Default Namespace Declarations, Namespace Declarations in Queries, Namespace Declarations in Element Constructors, Names affected by namespace declarations, W3C XML Schema: A Brief Overview, Element and Attribute Declarations, Sequence Types and Schemas
- atomic values, Atomic Values
- computed attribute constructors, Computed Attribute Constructors
- declarations in XML Schema, Element and Attribute Declarations
- enclosed expressions in direct element constructors evaluating to, Enclosed expressions that evaluate to attributes
- finding with path expressions, Path Expressions
- from input document, including in query results, Including Elements and Attributes from the Input Document
- including with result elements, using enclosed expressions, Specifying Attributes Directly
- matching based on name, Sequence Types and Schemas
- names, Node identity and name, Names affected by namespace declarations
- affected by namespace declarations in XQuery, Names affected by namespace declarations
- namespaces, Namespaces, Declaring Namespaces, Default Namespace Declarations, Namespace Declarations in Queries, Namespace Declarations in Element Constructors
- declaration attributes, Namespace Declarations in Element Constructors
- predeclared, Namespace Declarations in Queries
- prefixes, Declaring Namespaces
- node hierarchy (family analogy), The node hierarchy
- string and type values, Node identity and name
- types, W3C XML Schema: A Brief Overview
- averages, Aggregating on Multiple Values, Empty and nil values, Functions on Numbers
- avg function, Functions on Numbers
- avg-empty-is-zero function, Aggregating on Multiple Values
- calculating with missing values, Empty and nil values
- axes, Steps, Axes, Axes, Node kind tests, Node kind tests, Positional predicates and reverse axes, Conformance
- abbreviated syntax, Node kind tests
- forward, Steps
- Full Axis feature, Conformance
- reverse, Axes, Positional predicates and reverse axes
- positional predicates and, Positional predicates and reverse axes
- using node( ) test with, Node kind tests
- axis steps, Steps, Node name tests
- node tests, Node name tests
B
- back-references, Back-References
- (backslash), Representing Individual Characters, Escaping Rules for Character Class Expressions, Using Flags
- back references, Using Flags
- character escapes in regular expressions, Representing Individual Characters
- escaping in character class expressions, Escaping Rules for Character Class Expressions
- base URIs, Working with URIs, Using the xml:base attribute, Using the xml:base attribute, The base URI of the static context, The base URI of the static context
- finding for a node, Using the xml:base attribute
- of the static context, The base URI of the static context
- resolving URIs, The base URI of the static context
- specifying with xml:base attribute, Using the xml:base attribute
- base-URI declaration, The base URI of the static context
- base-uri function, Using the xml:base attribute
- BETWEEN condition (SQL), Comparisons
- between function, Node Comparisons
- binary data, xs:base64Binary, xs:gYearMonth
- xs:base64Binary type, xs:base64Binary
- xs:hexBinary type, xs:gYearMonth
- binding sequence, The for Clause
- block escapes in regular expressions, Block Escapes, Block Escapes
- examples, Block Escapes
- body, functions, Functions and Context
- invalid use of context, Functions and Context
- body, queries, Structure of a Query: Prolog and Body, Assembling Queries from Multiple Modules, Variable Declaration Syntax
- main module, Assembling Queries from Multiple Modules
- variable bindings, Variable Declaration Syntax
- boolean operators in SQL and XQuery, Arithmetic and string operators
- Boolean values, Literals, Conditional Expressions and Effective Boolean Values, Logical (and/or) Expressions, Negating a Boolean Value, Comparisons in Predicates, The return Clause, Quantified Expressions, Effective Boolean Value, xs:boolean
- combining in logical expressions, Logical (and/or) Expressions
- effective Boolean values, Conditional Expressions and Effective Boolean Values, Comparisons in Predicates, The return Clause, Effective Boolean Value
- calculated for FLWOR where expression, The return Clause
- conditional expressions and, Conditional Expressions and Effective Boolean Values
- sequences treated as, Effective Boolean Value
- literal, using in expressions, Literals
- negating, Negating a Boolean Value
- quantified expressions evaluated to, Quantified Expressions
- xs:boolean type, xs:boolean
- boundary whitespace (in direct element constructors), Direct Element Constructors and Whitespace
- boundary-space declaration, The boundary-space declaration
- branches (in regular expressions), Using Flags
- built-in functions, Built-in Versus User-Defined Functions, User-Defined Functions, Shared Components, Built-in Function Reference
- numeric keyword, use in signature, User-Defined Functions
- reference, Built-in Function Reference
- shared by XQuery and XSLT 2.0, Shared Components
- user-defined vs., Built-in Versus User-Defined Functions
C
- canonical representation, primitive types, The Built-in Types
- ^ (caret), Representing Individual Characters, Subtraction from a Range, Anchors, Using Flags
- beginning-of-line matching in regular expressions, multi-line mode and, Using Flags
- beginning-of-string matching in regular expressions, Anchors
- escaping in regular expressions, Representing Individual Characters
- negating character class in regular expressions, Subtraction from a Range
-
(carriage return), in regular expressions, Representing Any Character
- carriage return (
), in regular expressions, Representing Any Character
- case clauses (typeswitch expressions), The Typeswitch Expression
- case-insensitive matching, Using Flags
- case-sensitivity, keywords and names, Keywords and Names
- casting, Types, User-Defined Functions, Subtype Substitution, Constructors, The Castable Expression, Casting Rules, The Treat Expression, Functions on Numbers, Comparing Dates and Times, Casting and Comparing xs:anyURI Values, xs:boolean, Casting xs:decimal Values, Casting xs:double Values, xs:float, Casting and Comparing xs:hexBinary Values, xs:int
- cast expression, Constructors, The Treat Expression
- castable expression, The Castable Expression
- date/time types, Comparing Dates and Times
- function conversions and, User-Defined Functions
- functions on sequences of numbers, Functions on Numbers
- rules, Casting Rules
- untyped values, Subtype Substitution
- xs:anyURI values, Casting and Comparing xs:anyURI Values
- xs:boolean values, xs:boolean
- xs:decimal values, Casting xs:decimal Values
- xs:double values, Casting xs:double Values
- xs:float values, xs:float
- xs:hexBinary values, Casting and Comparing xs:hexBinary Values
- xs:integer values, xs:int
- catalog.xml document (example), Easing into XQuery
- category escapes in regular expressions, Block Escapes
- examples, Block Escapes
- CDATA sections, CDATA Sections
- ceiling function, Functions on Numbers
- change-elem-names function, Changing Names
- change-element-ns function, Other Name-Related Functions
- character classes, Character Class Expressions, Character Class Expressions, Escaping Rules for Character Class Expressions
- escaping rules, Escaping Rules for Character Class Expressions
- single characters and ranges, Character Class Expressions
- character encodings, The Version Declaration
- character references, Forcing boundary whitespace preservation, Representing Any Character, XML Entity and Character References, CDATA Sections
- in queries, CDATA Sections
- to whitespace characters in direct element constructors, Forcing boundary whitespace preservation
- XML syntax, using in regular expressions, Representing Any Character
- C (character that cannot be part of an XML name) in regular expressions, Category Escapes
- characters, Multiple module imports
- characters.xq module, Multiple module imports
- checking types in XQuery, Type Checking in XQuery
- child elements, Removing Child Elements, Simple and complex types
- removing, Removing Child Elements
- children (nodes), The node hierarchy
- circular module imports, Multiple module imports
- clarity of queries, Function Declarations, Query Design Goals, Using Comments for Documentation
- user-defined functions and, Function Declarations
- using comments for documentation, Using Comments for Documentation
- codepoints-to-string function, Concatenating and Splitting Strings, Converting Between Code Points and Strings
- collations, Order modifiers, Internationalization Considerations, Collations, Working with URIs
- default collation declaration, Collations
- specifying sort order of strings, Order modifiers
- URIs, Working with URIs
- collection function, Accessing a Single Document, The base URI of the static context
- base URI of the static context, The base URI of the static context
- : (colon), Finding the URI of a document, Working with IDs
- separator character in URIs, Finding the URI of a document
- XML name with no colon (NCName), Working with IDs
- , (comma), The Context, General comparisons and types, The where Clause, Combining Results, Finding the URI of a document
- concatenating sequences with sequence constructor, Combining Results
- interaction with parentheses and curly braces in XQuery, General comparisons and types
- separating expressions, The Context
- separator character in URIs, Finding the URI of a document
- using between adjacent FLWOR clauses, The where Clause
- comment nodes, The node hierarchy
- comments, Function Calls, Function Calls, Working with Other XML Components, XML Comments, Processing Instructions
- XML, Function Calls, Working with Other XML Components, XML Comments
- data model and, XML Comments
- included in queries, Function Calls
- XQuery, Function Calls, Processing Instructions
- not included in query results, Processing Instructions
- compare function, Collations
- collations, Collations
- comparisons, Categories of Expressions, General Comparisons, General Comparisons, General comparisons on multi-item sequences, General comparisons on multi-item sequences, Value Comparisons, Node Comparisons, Joins, Order Comparisons, Do You Need to Care About Types?, Numeric Type Promotion, The xs:string Constructor and the string Function, Collations, Finding the time zone of a value, Comparing Durations, The Date Component Types, Comparisons
- comparison expressions, Categories of Expressions
- date component types, The Date Component Types
- dates and times, Finding the time zone of a value
- deep-equal function, Joins
- default collation, using, Collations
- durations, Comparing Durations
- general comparisons, General Comparisons, General comparisons on multi-item sequences, General comparisons on multi-item sequences
- on multi-item sequences, General comparisons on multi-item sequences
- types and, General comparisons on multi-item sequences
- in SQL as compared to XQuery, Comparisons
- node comparisons, Node Comparisons
- numeric values, Numeric Type Promotion
- relative position in document order, Order Comparisons
- strings, The xs:string Constructor and the string Function
- untyped values, using general comparison operators, Do You Need to Care About Types?
- value comparisons, Value Comparisons
- complex types, Simple and complex types
- components, Extracting Components of Dates, Times, and Durations
- extracting from dates, times, and durations, Extracting Components of Dates, Times, and Durations
- computed constructors, Adding Attributes, Adding Elements and Attributes to Results, Computed Constructors, Computed Element Constructors, Names of computed element constructors, Computed Attribute Constructors, Use Case: Turning Content to Markup, Constructing Comments, Documents, Constructing Document Nodes
- attribute constructors, Computed Attribute Constructors
- comment, Constructing Comments
- document, Constructing Document Nodes
- element constructors, Computed Element Constructors, Names of computed element constructors
- content of, Names of computed element constructors
- processing instruction, Documents
- transforming content into markup (example), Use Case: Turning Content to Markup
- concat function, Concatenating and Splitting Strings, Concatenating Strings
- concatenation, Combining Results, The intersect Expression
- merging sequences, Combining Results
- union expressions vs., The intersect Expression
- conditional expressions, Categories of Expressions, Conditional (if-then-else) Expressions, Stable ordering
- sorting order specifications, Stable ordering
- conditions, SQL and XQuery, Comparisons
- conformance, Conformance
- constant values in queries, Literals
- construction declaration, Types and Newly Constructed Elements and Attributes
- constructors, Adding XML Elements and Attributes, Adding Attributes, Sequences, Categories of Expressions, Literals, Adding Elements and Attributes to Results, Computed Constructors, Constructors and Casting, Time Zones, Constructing Qualified Names, Constructing IDs, Constructing Comments, Querying Processing Instructions, Documents, Constructing Text Nodes
- adding elements and attributes to query results, Adding XML Elements and Attributes
- computed, Computed Constructors
- constructor expressions, Categories of Expressions
- date and time types, Time Zones
- direct, Adding Attributes
- document node, Documents
- processing instruction, Querying Processing Instructions
- sequence, Sequences
- text node, Constructing Text Nodes
- type, converting literal values, Literals
- using xml:id attribute in element constructors, Constructing IDs
- XML comment, Constructing Comments
- xs:QName, Constructing Qualified Names
- contains function, Normalizing Whitespace
- collations and, Normalizing Whitespace
- content types for complex types, User-defined types
- context, The Context, Path Expressions and Context, A Closer Look at Context, XML Version Support
- path expressions and, Path Expressions and Context
- setting query context in different XQuery implementations, XML Version Support
- context item, The Context, The position and last functions, Working with the Context Node
- position within context sequence, The position and last functions
- context node, Path Expressions and Context, Setting the Context Node Outside the Query, A Closer Look at Context, A Closer Look at Context, Accessing the Root
- accessing the root, Accessing the Root
- changing, A Closer Look at Context
- setting outside of query, Setting the Context Node Outside the Query
- working with, A Closer Look at Context
- conversions, type, Types, Literals, Sequence Types, Subtype Substitution, Type Promotion, Atomization, Function Conversion Rules, Constructors and Casting, Constructors, The Castable Expression, Casting among the primitive types, Type Declarations
- automatic, Sequence Types, Subtype Substitution, Type Promotion, Atomization, Function Conversion Rules
- atomization, Atomization
- function conversion rules, Sequence Types, Function Conversion Rules
- subtype substitution, Subtype Substitution
- type promotion, Type Promotion
- casting, Constructors, The Castable Expression, Casting among the primitive types
- cast expression, Constructors
- castable expression, The Castable Expression
- rules for casting, Casting among the primitive types
- constructors, using, Constructors and Casting
- type constructors, using, Literals
- copy-namespaces declaration, Controlling the Copying of Namespace Declarations, Controlling the Copying of Namespace Declarations
- inherit or no-inherit settings, Controlling the Copying of Namespace Declarations
- count function, Aggregating Values
- cross-references, Working with IDs
- { } (curly braces), Adding Elements, General comparisons and types, Enclosed expressions that evaluate to attributes, Names of computed element constructors, The Function Body, Representing Any Character, Constructing Text Nodes
- enclosing function body, The Function Body
- escaping in regular expressions, Representing Any Character
- in computed element constructors, Names of computed element constructors
- in element constructors, Adding Elements, Enclosed expressions that evaluate to attributes
- enclosed expressions, Enclosed expressions that evaluate to attributes
- in text node constructors, Constructing Text Nodes
- interaction with parentheses and commas in XQuery, General comparisons and types
- current date and/or time, Constructing and Casting Dates and Times
D
- data function, Adding Elements, Atomic Values, Flexible Data Structures
- data model, The XQuery Data Model, The XQuery Data Model, Nodes, Atomic Values, Sequences, XML Comments, Processing Instructions and the Data Model, Document Nodes and the Data Model, Text Nodes and the Data Model, Relational Versus XML Data Models, Data Model
- atomic values, Atomic Values
- basic components, The XQuery Data Model
- differences in XQuery 1.0/XPath 1.0 and 2.0, Data Model
- document nodes and, Document Nodes and the Data Model
- nodes, Nodes
- processing instructions and, Processing Instructions and the Data Model
- relational vs. XML, Relational Versus XML Data Models
- sequences, Sequences
- text nodes and, Text Nodes and the Data Model
- XML comments and, XML Comments
- databases, Capabilities of XQuery, Easing into XQuery, Easing into XQuery
- native XML databases supporting XQuery, Easing into XQuery
- relational databases supporting XML and XQuery, Easing into XQuery
- dates and times, Literals, The Built-in Types, Constructors and Casting, Working with Dates, Times, and Durations, The Date and Time Types, Constructing and Casting Dates and Times, Time Zones, Adjusting time zones, Finding the time zone of a value, The Duration Types, Comparing Durations, Comparing Durations, Extracting Components of Dates, Times, and Durations, Using Arithmetic Operators on Dates, Times, and Durations, Adding and Subtracting Durations from Dates and Times, xs:date, xs:date, xs:time
- arithmetic operators, using on, Using Arithmetic Operators on Dates, Times, and Durations
- comparing, Finding the time zone of a value
- date formats, Adjusting time zones
- durations of time, The Duration Types, Comparing Durations, Comparing Durations
- comparing, Comparing Durations
- yearMonthDuration and dayTimeDuration types, Comparing Durations
- extracting components, Extracting Components of Dates, Times, and Durations
- including literal date in an expression, Literals
- subtracting durations from, Adding and Subtracting Durations from Dates and Times
- types, Constructors and Casting, Working with Dates, Times, and Durations, Constructing and Casting Dates and Times, Time Zones, xs:date, xs:date, xs:time
- constructing and casting, Constructors and Casting, Constructing and Casting Dates and Times
- time zones, Time Zones
- xs:date, xs:date
- xs:dateTime, xs:date
- xs:time, xs:time
- days, Extracting Components of Dates, Times, and Durations, xs:gDay, xs:gMonth
- extracting from dates, times, and durations, Extracting Components of Dates, Times, and Durations
- xs:gDay type, xs:gDay
- xs:gMonthDay type, xs:gMonth
- decimal digit character (d), in regular expressions, Representing Groups of Characters
- decimal numbers, The xs:decimal Type, xs:decimal
- xs:decimal type, xs:decimal
- declarations, Function Calls, Empty order, The ordering mode declaration, Why Define Your Own Functions?, Recursive Functions, Namespace URIs, Default Namespace Declarations, Namespace Declarations and Scope, Namespace Declarations in Queries, Namespace Declarations in Queries, The default function namespace declaration, The Impact and Scope of Namespace Declarations, Controlling Namespace Declarations in Your Results, Controlling the Copying of Namespace Declarations, Sequence Types, Structure of a Query: Prolog and Body, The Version Declaration, Assembling Queries from Multiple Modules, Variable Declarations, External Variables, Declaring External Functions, The Treat Expression, Collations, Resolving URIs, Setting the Query Context
- base URI, Resolving URIs
- default collation, Collations
- empty order, Empty order
- function, Function Calls, Why Define Your Own Functions?, Recursive Functions, Sequence Types, Declaring External Functions
- binding variables to values, Function Calls
- external functions, Declaring External Functions
- recursive functions, Recursive Functions
- sequence types, Sequence Types
- in query prolog, Structure of a Query: Prolog and Body
- module, Assembling Queries from Multiple Modules
- namespace, Namespace URIs, Default Namespace Declarations, Namespace Declarations and Scope, Namespace Declarations in Queries, Namespace Declarations in Queries, The default function namespace declaration, The Impact and Scope of Namespace Declarations, Controlling Namespace Declarations in Your Results, Controlling the Copying of Namespace Declarations
- controlling in query results, Controlling Namespace Declarations in Your Results
- copy-namespaces declaration, Controlling the Copying of Namespace Declarations
- default namespace, Default Namespace Declarations
- impact and scope in XQuery, The Impact and Scope of Namespace Declarations
- in element constructors, The default function namespace declaration
- query prolog, Namespace Declarations in Queries
- scope and, Namespace Declarations and Scope
- XQuery queries, Namespace Declarations in Queries
- option, Setting the Query Context
- ordering mode, The ordering mode declaration
- type, The Treat Expression
- variables, Variable Declarations, External Variables
- external, External Variables
- version, The Version Declaration
- deep-equal function, Joins
- default clause (typeswitch expressions), The Typeswitch Expression
- default collation declaration, Collations
- default namespace, Namespaces and XQuery, Default namespace declarations in the prolog, The default function namespace declaration, Names affected by namespace declarations
- declaring, Default namespace declarations in the prolog
- in query prologs, Default namespace declarations in the prolog
- functions, The default function namespace declaration, Names affected by namespace declarations
- overriding, Namespaces and XQuery
- derived types, The Built-in Types, Casting among derived types
- built-in, The Built-in Types
- casting among, Casting among derived types
- descendant-or-self axis, Avoid Expensive Path Expressions
- avoiding use in path expressions, Avoid Expensive Path Expressions
- descendants (nodes), Roots, documents, and elements
- descending or ascending order, Order modifiers
- d (digit) character in regular expressions, Representing Groups of Characters
- digit character (d), in regular expressions, Representing Groups of Characters
- direct constructors, Adding Attributes, Adding Elements and Attributes to Results, Constructing Comments, Querying Processing Instructions
- processing instruction, Querying Processing Instructions
- XML comment, Constructing Comments
- direct element constructors, Direct Element Constructors, Containing Enclosed Expressions, Declaring Namespaces in Direct Constructors, Use Case: Modifying an Element from the Input Document, Direct Element Constructors and Whitespace, Boundary whitespace, The boundary-space declaration, Forcing boundary whitespace preservation, Other prolog namespace declarations, Scope of namespace declarations, Controlling Namespace Declarations in Your Results, CDATA Sections
- containing enclosed expressions, Containing Enclosed Expressions
- modifying element from input document (example), Use Case: Modifying an Element from the Input Document
- namespace declarations, Declaring Namespaces in Direct Constructors, Other prolog namespace declarations, Scope of namespace declarations, Controlling Namespace Declarations in Your Results
- controlling in query results, Controlling Namespace Declarations in Your Results
- scope of, Scope of namespace declarations
- references in, CDATA Sections
- whitespace, Direct Element Constructors and Whitespace, Boundary whitespace, The boundary-space declaration, Forcing boundary whitespace preservation
- boundary whitespace, Boundary whitespace
- boundary-space declaration, The boundary-space declaration
- forcing boundary whitespace preservation, Forcing boundary whitespace preservation
- distinct values, Selecting Distinct Values, Selecting Distinct Values
- selecting (SQL vs. XQuery), Selecting Distinct Values
- distinct-deep function, Joins
- distinct-values function, Joins, Aggregating Values, Comparing Numeric Values, Collations, Combining SQL and XQuery
- collations, Collations
- NaN, Comparing Numeric Values
- using in FLWORs for grouping, Combining SQL and XQuery
- division, Keywords and Names, Arithmetic Operations, Division, Arithmetic and string operators
- div and idiv operators, Arithmetic Operations, Division
- SQL and XQuery operators, Arithmetic and string operators
- doc function, The base URI of the static context, Documents
- base URI of the static context, The base URI of the static context
- input document opened with, Documents
- document element, Roots, documents, and elements
- document nodes, The node hierarchy
- document order, Sorting in XQuery, Document Order, Inadvertent resorting in document order, Inadvertent resorting in document order
- inadvertent resorting in, Inadvertent resorting in document order
- sorting in, Inadvertent resorting in document order
- documents (XML), Documents, Conformance
- serialization of query results to, Conformance
- $ (dollar sign), Literals, The Function Name, Representing Individual Characters, Anchors, Using Flags, Using Sub-Expressions with Replacement Variables, Finding the URI of a document
- end-of-line matching in regular expressions, multi-line mode and, Using Flags
- end-of-string matching in regular expressions, Anchors
- escaping in regular expressions, Representing Individual Characters
- in variable names, Literals, The Function Name, Using Sub-Expressions with Replacement Variables
- function parameters, The Function Name
- replacement variables, Using Sub-Expressions with Replacement Variables
- separator character in URIs, Finding the URI of a document
- dot-all mode, Representing Any Character, Using Flags
- double-precision floating-point numbers, The xs:float and xs:double Types
- durations, The Duration Types, The yearMonthDuration and dayTimeDuration Types, The yearMonthDuration and dayTimeDuration Types, Comparing Durations, Adding and Subtracting Durations from Dates and Times, xs:dayTimeDuration, xs:duration, xs:yearMonthDuration
- adding and subtracting from dates and times, Adding and Subtracting Durations from Dates and Times
- comparing, Comparing Durations
- types, The Duration Types, The yearMonthDuration and dayTimeDuration Types, The yearMonthDuration and dayTimeDuration Types, xs:dayTimeDuration, xs:duration, xs:yearMonthDuration
- xs:dayTimeDuration, The yearMonthDuration and dayTimeDuration Types, xs:dayTimeDuration
- xs:duration, The Duration Types, xs:duration
- xs:yearMonthDuration, The yearMonthDuration and dayTimeDuration Types, xs:yearMonthDuration
- dynamic errors, Error Handling, Avoiding Dynamic Errors, The error and trace Functions
- caused by variations in input documents, The error and trace Functions
- type errors, Avoiding Dynamic Errors
- dynamic evaluation phase (type checking), Type Checking in XQuery
- dynamic paths, Dynamic Paths
E
- element nodes, Nodes
- element( ) kind test, Sequence Types, Sequence Types and Schemas
- element-only content, Function Conversion Rules, Nodes and Typed Values
- elements, Path Expressions, Adding XML Elements and Attributes, The node hierarchy, Roots, documents, and elements, Node identity and name, Node identity and name, Atomic Values, Namespaces, Including Elements and Attributes from the Input Document, Direct Element Constructors, Computed Element Constructors, Copying Input Elements with Modifications, Removing Child Elements, Changing Names, Declaring Namespaces, Names affected by namespace declarations, In-Scope Versus Statically Known Namespaces, W3C XML Schema: A Brief Overview, Sequence Types and Schemas
- adding to query results, Adding XML Elements and Attributes
- atomic values, Atomic Values
- computed element constructors, Computed Element Constructors
- copying with modifications, Removing Child Elements, Changing Names
- changing names, Changing Names
- removing child elements, Removing Child Elements
- direct element constructors, Direct Element Constructors
- finding with path expressions, Path Expressions
- in-scope namespaces, In-Scope Versus Statically Known Namespaces
- input document, Including Elements and Attributes from the Input Document, Copying Input Elements with Modifications
- copying with modifications in query, Copying Input Elements with Modifications
- including in query results, Including Elements and Attributes from the Input Document
- matching based on name, Sequence Types and Schemas
- names, Node identity and name
- names affected by namespace declarations in XQuery, Names affected by namespace declarations
- namespace prefixes, Declaring Namespaces
- namespaces, Namespaces
- node hierarchy (family analogy), The node hierarchy
- roots and documents, Roots, documents, and elements
- string and typed values, Node identity and name
- types, W3C XML Schema: A Brief Overview
- else keyword, Conditional (if-then-else) Expressions
- empty and nil values, Empty and nil values
- empty content, Nodes and Typed Values
- empty element, Relational Versus XML Data Models
- empty greatest or empty least order, Order modifiers
- empty order declaration, Empty order
- empty sequence, Sequences, General comparisons on multi-item sequences, Value Comparisons, Accepting arguments that are nodes versus atomic values, The base URI of the static context
- base URI of the static context, The base URI of the static context
- in function arguments, Accepting arguments that are nodes versus atomic values
- in general comparisons, General comparisons on multi-item sequences
- in value comparisons, Value Comparisons
- enclosed expressions, Direct Element Constructors, Enclosed expressions that evaluate to attributes, Enclosed expressions with multiple subexpressions, Declaring Namespaces in Direct Constructors, Boundary whitespace, Forcing boundary whitespace preservation, Names of computed element constructors, Content of computed element constructors
- containing element content, Names of computed element constructors
- elements returned by, Content of computed element constructors
- evaluating to atomic values, Enclosed expressions that evaluate to attributes
- evaluating to whitespace, Forcing boundary whitespace preservation
- evaluation in attribute values, Declaring Namespaces in Direct Constructors
- whitespace in, Boundary whitespace
- with multiple subexpressions, Enclosed expressions with multiple subexpressions
- entity references, String Literals, Representing Any Character, XML Entity and Character References, XML Entity and Character References, XML Entity and Character References
- predefined, XML Entity and Character References
- query using (example), XML Entity and Character References
- XML syntax, using in regular expressions, Representing Any Character
- equal to operator, General Comparisons, Value Comparisons, Removing Attributes from an Element, Comparing Numeric Values, Arithmetic Operations, Comparing Dates and Times, Comparing Durations, Comparisons
- =, General Comparisons, Removing Attributes from an Element, Comparing Numeric Values, Comparing Dates and Times, Comparing Durations, Comparisons
- comparing dates and times, Comparing Dates and Times
- comparing durations, Comparing Durations
- comparing numeric values, Comparing Numeric Values
- used on lists of values, Removing Attributes from an Element
- eq, Value Comparisons, Arithmetic Operations
- comparing numeric values, Arithmetic Operations
- = (equals sign), Evaluation Order and Parentheses, Negating a Boolean Value, Joins and Types, Removing Attributes from an Element, Comparing Numeric Values, Comparing Dates and Times, Comparing Durations, Finding the URI of a document, Comparisons, Arithmetic and string operators
- equal to operator, Evaluation Order and Parentheses, Negating a Boolean Value, Joins and Types, Removing Attributes from an Element, Comparing Numeric Values, Comparing Dates and Times, Comparing Durations, Comparisons, Arithmetic and string operators
- != operator vs. not function in expression using =, Negating a Boolean Value
- comparing dates and times, Comparing Dates and Times
- comparing durations, Comparing Durations
- comparing numeric values, Comparing Numeric Values
- SQL and XQuery, Comparisons
- used on lists of values, Removing Attributes from an Element
- separator character in URIs, Finding the URI of a document
- errors, Atomic Values and Types, Type Checking in XQuery, Type Checking in XQuery, Error Handling, Serialization, FOAR0001
- handling with good query design, Error Handling
- reference (in alphabetical order by name), FOAR0001
- serialization, Serialization
- type, Atomic Values and Types, Type Checking in XQuery, Type Checking in XQuery
- dynamic errors, checking for, Type Checking in XQuery
- static errors, checking for, Type Checking in XQuery
- escapes, Representing Individual Characters, Representing Groups of Characters, Escaping Rules for Character Class Expressions, Documents and URIs, XML Entity and Character References, XML Entity and Character References
- character class expressions, Escaping Rules for Character Class Expressions
- character references, XML Entity and Character References
- entity references, XML Entity and Character References
- representing groups of characters in regular expressions, Representing Groups of Characters
- single characters in regular expressions, Representing Individual Characters
- URIs, Documents and URIs
- evaluation (run) time, What Is Static Typing?
- every (keyword), Keywords and Names, Binding Multiple Variables
- exactly-one function, Type Declarations in Global Variable Declarations
- ! (exclamation mark), Evaluation Order and Parentheses, Removing Attributes from All Descendants, Comparing Numeric Values, Finding the time zone of a value, Full-Text Search, Comparisons
- ! (not) full text operator, Full-Text Search
- != (not equal to) operator, Evaluation Order and Parentheses, Removing Attributes from All Descendants, Comparing Numeric Values, Finding the time zone of a value, Comparisons
- comparing dates and times, Finding the time zone of a value
- comparing numeric values, Comparing Numeric Values
- not function vs., Removing Attributes from All Descendants
- SQL and XQuery, Comparisons
- exists function, Flexible Data Structures
- SQL Server, Flexible Data Structures
- expressions, Expressions: XQuery Building Blocks, Categories of Expressions, Keywords and Names, Evaluation Order and Parentheses, Avoid Reevaluating the Same or Similar Expressions
- categories of, Categories of Expressions
- evaluation order and parentheses, Evaluation Order and Parentheses
- reevaluating, Avoid Reevaluating the Same or Similar Expressions
- whitespace in queries, Keywords and Names
- extension expressions, Extension Expressions
- external variables, External Variables
F
- false function, Literals
- family relationships among nodes, The node hierarchy
- flags (in regular expressions), Using Flags
- floating-point numbers, The xs:float and xs:double Types, xs:float
- xs:float type, xs:float
- floor function, Functions on Numbers
- FLWORs, FLWORs, Adding XML Elements and Attributes, Categories of Expressions, Keywords and Names, Function Calls, Selecting and Joining Using FLWORs, FLWOR Expressions, FLWOR Expressions, The for Clause, The let Clause, The where Clause, Quantified Expressions, Joins, Joins, Joins, Three-Way Joins, Sorting in XQuery, The order by Clause, Inadvertent resorting in document order, Grouping, Sequence Type Matching, Type Declarations in FLWORs, Subselects, Combining SQL and XQuery
- binding variables, Function Calls
- clauses, listed, Adding XML Elements and Attributes, FLWOR Expressions
- distinct-values function, using, Combining SQL and XQuery
- embedded in another FLWOR, Subselects
- for clause, The for Clause
- grouping results into categories, Grouping
- joining data from multiple sources, Joins, Joins, Three-Way Joins
- three-way joins, Three-Way Joins
- two-way join in a predicate, Joins
- let clause, The let Clause
- order by clause, The order by Clause, Inadvertent resorting in document order
- inadvertent resorting in document order, Inadvertent resorting in document order
- order of returns, Sorting in XQuery
- scope of variables, Quantified Expressions
- selecting distinct values, Joins
- sequence type matching, Sequence Type Matching
- syntax, FLWOR Expressions
- type declarations, Type Declarations in FLWORs
- where clause, The where Clause
- fn namespace, Namespace Declarations in Queries
- following axis, Conformance
- following-sibling axis, Conformance
- for clause (FLWORs), Adding XML Elements and Attributes, FLWOR Expressions, The for Clause, Multiple for clauses, The let Clause, Quantified Expressions, Sorting in XQuery
- intermingled with let clauses, The let Clause
- multiple for clauses, Multiple for clauses
- order of results, Sorting in XQuery
- scope of variables, Quantified Expressions
- forward steps, Steps
- axis, Steps
- fragment identifiers in URI references, Working with URIs
- ftcontains operator, XQuery API for Java (XQJ)
- full-text searches, XQuery Update Facility
- function conversion rules, Sequence Types, Function Conversion Rules
- function namespace, Names affected by namespace declarations
- functions, Functions, Namespaces, Function Calls, Functions, Built-in Versus User-Defined Functions, Built-in Versus User-Defined Functions, Function Names, Function Names, User-Defined Functions, Function Declarations, Function Declarations, The Parameter List, Recursive Functions, Namespace Declarations and Scope, Default namespace declarations in the prolog, Names affected by namespace declarations, Functions, Built-in Function Reference
- body, Function Declarations
- built-in, Built-in Versus User-Defined Functions, Built-in Function Reference
- reference, Built-in Function Reference
- user-defined vs., Built-in Versus User-Defined Functions
- calling, Function Calls, Built-in Versus User-Defined Functions, Function Names, Function Names, User-Defined Functions
- function names, Function Names
- function signatures, Function Names
- sequence types for parameters, User-Defined Functions
- declarations, Function Declarations
- names of, Namespaces, Namespace Declarations and Scope, Default namespace declarations in the prolog, Names affected by namespace declarations
- default namespace declaration, Default namespace declarations in the prolog
- impact of namespace declarations, Names affected by namespace declarations
- namespaces, Namespaces, Namespace Declarations and Scope
- parameter list, The Parameter List
- recursive, Recursive Functions
- SQL and XQuery equivalents, Functions
G
- generic sequence types, Generic Sequence Types
- generic types, W3C XML Schema: A Brief Overview, Assigning Type Annotations to Nodes
- assigned when no schema is present, W3C XML Schema: A Brief Overview
- assignment to elements or attributes, Assigning Type Annotations to Nodes
- global attributes, Namespaces and Attributes
- global variables, Variables, Variable Declarations
- declarations, Variables
- greater than operator, Evaluation Order and Parentheses, Value Comparisons, Comparing Numeric Values, Arithmetic Operations, Comparing Dates and Times, Extracting Components of Dates, Times, and Durations, XML Entity and Character References, Comparisons
- >, Evaluation Order and Parentheses, Comparing Numeric Values, Comparing Dates and Times, Extracting Components of Dates, Times, and Durations, XML Entity and Character References, Comparisons
- comparing dates and times, Comparing Dates and Times
- comparing durations, Extracting Components of Dates, Times, and Durations
- comparing numeric values, Comparing Numeric Values
- entity reference (>:), XML Entity and Character References
- SQL and XQuery, Comparisons
- gt, Value Comparisons, Arithmetic Operations
- comparing numeric values, Arithmetic Operations
- greater than or equal to operator, General Comparisons, Value Comparisons, Comparing Numeric Values, Arithmetic Operations, Finding the time zone of a value, Comparisons
- >=, General Comparisons, Comparing Numeric Values, Finding the time zone of a value, Comparisons
- comparing dates and times, Finding the time zone of a value
- comparing numeric values, Comparing Numeric Values
- SQL and XQuery, Comparisons
- ge, Value Comparisons, Arithmetic Operations
- comparing numeric values, Arithmetic Operations
- grouping, Aggregating and Grouping Values, Grouping, Subselects
- SQL vs. XQuery, Subselects
- groups of characters, representing in regular expressions, Representing Groups of Characters
H
- hours, Extracting Components of Dates, Times, and Durations
- extracting from dates, times, and durations, Extracting Components of Dates, Times, and Durations
- HTML, XML Entity and Character References
- entities, XML Entity and Character References
- - (hyphen), subtraction from character class range in regular expressions, Processing Instructions
- in XML comments, Processing Instructions
I
- i option ($flags argument), indicating case-insensitive mode, Using Flags
- id function, Joining IDs and IDREFs
- identity (nodes), Node identity and name
- idiv (integer division) operator, Arithmetic Operations, Division
- IDREFs, Working with IDs, xs:IDREF, xs:IDREF
- xs:IDREF type, xs:IDREF
- xs:IDREFS type, xs:IDREF
- IDs (identifiers), Working with IDs
- if, then, and else keywords, Conditional (if-then-else) Expressions
- if-absent function, Empty and nil values
- if-empty function, Error Handling
- if-then-else expressions, Conditional (if-then-else) Expressions, Logical (and/or) Expressions, The Treat Expression
- typeswitch expression vs., The Treat Expression
- use of logical (and/or) operators, Logical (and/or) Expressions
- implementation-defined features, Conformance, XML Version Support, The Option Declaration, Specifying Serialization Parameters
- default values for serialization parameters, Specifying Serialization Parameters
- option declaration, The Option Declaration
- implementation-dependent features, Conformance
- implementation-specific aspects, XQuery, Conformance, Conformance, XML Version Support, XML Version Support, Option Declarations and Extension Expressions, Extension Expressions, Specifying Serialization Parameters
- conformance, Conformance
- extension expressions, Extension Expressions
- option declarations, Option Declarations and Extension Expressions
- serialization parameters, specifying, Specifying Serialization Parameters
- setting query context, XML Version Support
- XML version support, XML Version Support
- implicit time zones, Adjusting time zones, The Duration Types
- implicit-timezone function, Adjusting time zones
- in date and time comparisons, The Duration Types
- imports, Importing a Library Module, Multiple module imports, Multiple module imports, Where Do In-Scope Schema Definitions Come from?, Where Do In-Scope Schema Definitions Come from?, Conformance, Conformance
- library modules, Importing a Library Module, Multiple module imports, Multiple module imports, Conformance
- behavior of imported module, Multiple module imports
- multiple, Multiple module imports
- support for, Conformance
- schema, Where Do In-Scope Schema Definitions Come from?, Where Do In-Scope Schema Definitions Come from?, Conformance
- adding to ISSD for a module, Where Do In-Scope Schema Definitions Come from?
- in (keyword), Keywords and Names
- IN condition (SQL), Arithmetic and string operators
- in-scope namespaces, Controlling Namespace Declarations in Your Results
- statically known namespaces vs., Controlling Namespace Declarations in Your Results
- in-scope-prefixes function, Working with URIs
- index in path expression predicate, FLWORs
- index-of function, Sequences
- use with sequences, Sequences
- INF and -INF (positive and negative infinity), Arithmetic Operations
- i (initial) character allowed as first character of XML names, Representing Groups of Characters
- initial character (i), allowed in XML names, Representing Groups of Characters
- initializing expressions, Variable Names
- input documents, Processing Queries, Namespaces, Input Documents, Including Elements and Attributes from the Input Document, Copying Input Elements with Modifications, Namespace Declarations and Scope, Namespace declarations and input elements, Modularity
- copying elements with modifications in query, Copying Input Elements with Modifications
- including elements and attributes in query results, Including Elements and Attributes from the Input Document
- namespace declaration, Namespaces, Namespace declarations and input elements
- input elements and, Namespace declarations and input elements
- namespaces, Namespace Declarations and Scope
- variations in, designing robust queries for, Modularity
- insert-before function, The Built-in Types
- value type for second argument, The Built-in Types
- instance of expressions, The Treat Expression
- used in if-then-else expressions, The Treat Expression
- integer division (idiv) operator, Arithmetic Operations
- integers, The xs:integer Type, xs:byte, xs:int, xs:integer, xs:long, xs:long, xs:NMTOKEN, xs:NMTOKEN, xs:NOTATION, xs:short, xs:token, xs:token, xs:unsignedShort, xs:unsignedShort
- xs:byte type, xs:byte
- xs:int type, xs:int
- xs:integer type, xs:integer
- xs:long type, xs:long
- xs:negativeInteger type, xs:long
- xs:nonNegativeInteger type, xs:NMTOKEN
- xs:nonPositiveInteger type, xs:NMTOKEN
- xs:positiveInteger type, xs:NOTATION
- xs:short type, xs:short
- xs:unsignedByte type, xs:token
- xs:unsignedInt type, xs:token
- xs:unsignedLong type, xs:unsignedShort
- xs:unsignedShort type, xs:unsignedShort
- intermediate XML documents, Reducing Complexity
- reducing complexity of input document, Reducing Complexity
- International Resource Identifiers (IRIs), XML Namespaces
- internationalization of strings, Internationalization Considerations, Unicode Normalization, Unicode Normalization
- collations, Internationalization Considerations
- determining language of an element, Unicode Normalization
- Unicode normalization, Unicode Normalization
- IRIs (International Resource Identifiers), XML Namespaces
- is operator, Testing for the Last Item
- testing for last item, Testing for the Last Item
- ISSDs (in-scope schema definitions), Namespaces and XML Schema, Obvious Static Type Errors
- static typing and, Obvious Static Type Errors
L
- languages, xs:language
- xs:language type, xs:language
- last function, The position and last functions, Built-in Function Reference
- lax validation mode, Validation Mode
- length of a string, Finding the Length of a String, Whitespace and Strings
- finding, Finding the Length of a String
- whitespace and, Whitespace and Strings
- less than operator, Evaluation Order and Parentheses, Value Comparisons, Comparing Numeric Values, Arithmetic Operations, Representing Any Character, Comparing Dates and Times, Extracting Components of Dates, Times, and Durations, XML Entity and Character References
- <, Evaluation Order and Parentheses, Comparing Numeric Values, Representing Any Character, Comparing Dates and Times, Extracting Components of Dates, Times, and Durations, XML Entity and Character References
- comparing dates and times, Comparing Dates and Times
- comparing durations, Extracting Components of Dates, Times, and Durations
- comparing numeric values, Comparing Numeric Values
- entity reference (<), Representing Any Character, XML Entity and Character References
- lt, Value Comparisons, Arithmetic Operations
- comparing numeric values, Arithmetic Operations
- less than or equal to operator, General Comparisons, Value Comparisons, Comparing Numeric Values, Arithmetic Operations, Finding the time zone of a value, Comparisons
- <=, General Comparisons, Comparing Numeric Values, Finding the time zone of a value, Comparisons
- comparing dates and times, Finding the time zone of a value
- comparing numeric values, Comparing Numeric Values
- SQL and XQuery, Comparisons
- le, Value Comparisons, Arithmetic Operations
- comparing numeric values, Arithmetic Operations
- let clause (FLWORs), Adding XML Elements and Attributes, FLWOR Expressions, Quantified Expressions, Aggregating Values
- binding entire sequence of items to a variable, Aggregating Values
- scope of variables, Quantified Expressions
- lexical representation, primitive types, The Built-in Types
- library modules, Assembling Queries from Multiple Modules, Importing a Library Module, Multiple module imports, The behavior of a module import, Variable Names, Importing a schema with no target namespace, Modularity, Conformance
- functions separated into for reuse, Modularity
- importing, Importing a Library Module, Multiple module imports, The behavior of a module import
- behavior of a module import, The behavior of a module import
- multiple, Multiple module imports
- schema imports and, Importing a schema with no target namespace
- support for, Conformance
- variable names, Variable Names
- LIKE conditions (SQL), Comparisons
-
(line feed), in regular expressions, Representing Any Character
- line feed (
), in regular expressions, Representing Any Character
- list types, User-defined types, Nodes and Typed Values
- and typed values, Nodes and Typed Values
- literals, Literals, Default namespace declarations in the prolog, The Numeric Types, Constructing Strings
- namespace name in XQuery namespace declaration, Default namespace declarations in the prolog
- numeric literals, The Numeric Types
- string literals, Constructing Strings
- local namespace, Namespace Declarations in Queries
- local-name function, Node identity and name, Working with Qualified Names
- logical expressions, Categories of Expressions, Logical (and/or) Expressions, Logical (and/or) Expressions
- evaluation order, Logical (and/or) Expressions
M
- m option ($flags argument), indicating multi-line mode, Using Flags
- main module, Assembling Queries from Multiple Modules
- matches function, Matching a String to a Pattern, Representing Any Character, Using Flags, Comparisons
- dot-all mode, Representing Any Character
- flags, Using Flags
- max function, Functions on Numbers
- min function, Functions on Numbers
- - (minus sign), Arithmetic Operations, Arithmetic Operations, Representing Individual Characters, The Duration Types, Adding and Subtracting Two Durations
- escaping in regular expressions, Representing Individual Characters
- negation operator, Arithmetic Operations
- negative durations, The Duration Types
- subtraction operator, Arithmetic Operations, Adding and Subtracting Two Durations
- subtracting durations, Adding and Subtracting Two Durations
- minutes, Extracting Components of Dates, Times, and Durations
- extracting from dates, times, and durations, Extracting Components of Dates, Times, and Durations
- missing values, Counting "Missing" Values, Empty and nil values, Empty and nil values, Relational Versus XML Data Models
- handling with robust query design, Empty and nil values, Empty and nil values
- default missing values, Empty and nil values
- empty and nil values, Empty and nil values
- in sequence passed to aggregation function, Counting "Missing" Values
- counting, Counting "Missing" Values
- mixed content, User-defined types, Why Work with Text Nodes?
- in complex types, User-defined types
- in text nodes, Why Work with Text Nodes?
- MMDDYYYY-to-date function, Adjusting time zones
- mod (modulus) operator, Arithmetic Operations
- modifiers, order, Order modifiers
- modularity of queries, Modularity
- module declaration, Library Modules
- modules, Assembling Queries from Multiple Modules, Assembling Queries from Multiple Modules, Assembling Queries from Multiple Modules, Importing a Library Module, Variable Names, Conformance
- library, Assembling Queries from Multiple Modules, Importing a Library Module, Variable Names
- importing, Importing a Library Module
- variable names, Variable Names
- main, Assembling Queries from Multiple Modules
- support for library modules and module imports, Conformance
- months, Extracting Components of Dates, Times, and Durations, xs:gMonth, xs:gYearMonth
- extracting from dates, times, and durations, Extracting Components of Dates, Times, and Durations
- xs:gMonth type, xs:gMonth
- xs:gYearMonth, xs:gYearMonth
- multi-character escapes in regular expressions, Representing Groups of Characters, Block Escapes
- examples, Block Escapes
- multi-line mode, Anchors and Multi-Line Mode, Using Flags
- m option ($flags argument), Using Flags
- multiplication, Addition, Subtraction, and Multiplication, Arithmetic and string operators
- SQL and XQuery operators, Arithmetic and string operators
N
- N/A values, indicating default missing values, Empty and nil values
- name function, Node identity and name
- names, Node identity and name, Node identity and name, Node identity and name, Node identity and name, Keywords and Names, Literals, Dynamic Paths, Names of computed element constructors, Calling Functions, The Function Body, The Function Name, Names affected by namespace declarations, The Scope of Variables, Working with Qualified Names, Working with Qualified Names, Working with Qualified Names, xs:long
- affected by namespace declarations in XQuery, Names affected by namespace declarations
- computed element constructors, Names of computed element constructors
- conventions in XQuery, Keywords and Names
- element and attribute nodes, Node identity and name
- function, Calling Functions, The Function Body, The Function Name
- reserved, The Function Name
- local-name function, Node identity and name, Working with Qualified Names
- name function, Node identity and name, Dynamic Paths, Working with Qualified Names
- node-name function, Node identity and name, Working with Qualified Names
- valid name in XML (xs:Name), xs:long
- variables, Literals, The Scope of Variables
- namespace declaration attributes, Namespace Declarations in Element Constructors, In-Scope Versus Statically Known Namespaces
- namespace-uri function, Working with Qualified Names
- namespace-uri-for-prefix function, Working with URIs
- namespaces, Namespaces, Keywords and Names, Literals, Node name tests and namespaces, Function Names, The Function Name, Namespaces and XQuery, Namespaces and XQuery, Namespace URIs, Default Namespace Declarations, Namespace Declarations and Scope, Namespace Declarations in Queries, Namespace Declarations in Queries, The default function namespace declaration, Names affected by namespace declarations, Controlling Namespace Declarations in Your Results, Importing a Library Module, Multiple module imports, XML Version Support, FOAR0001
- declarations in element constructors, The default function namespace declaration
- declarations in prolog, Namespace Declarations in Queries
- default namespace declarations in queries, Names affected by namespace declarations
- error names, FOAR0001
- functions, Function Names
- in-scope, Controlling Namespace Declarations in Your Results
- statically known namespaces vs., Controlling Namespace Declarations in Your Results
- library module imports, Importing a Library Module, Multiple module imports
- multiple module locations for single namespace, Multiple module imports
- names in XQuery, Keywords and Names
- node name tests and, Node name tests and namespaces
- predeclared, Namespace Declarations in Queries
- user-defined function names, The Function Name
- variables, Literals
- XML, Namespaces and XQuery, Namespace URIs, Default Namespace Declarations, Namespace Declarations and Scope
- declarations and scope, Namespace Declarations and Scope
- default namespace declarations, Default Namespace Declarations
- URIs, Namespace URIs
- XML versions, XML Version Support
- Namespaces in XML (W3C recommendation), XML Namespaces
- NaN (not-a-number), Order modifiers, Arithmetic Operations
- comparisons, Arithmetic Operations
- sorting order, Order modifiers
- native XML database, Uses for XQuery
- NCName, Working with IDs, Documents, xs:Name
- target for processing instructions, Documents
- negation operator (-), Arithmetic Operations
- negative durations, The Duration Types
- negative infinity (-INF), Arithmetic Operations
- nesting, Nesting Conditional Expressions, Subselects
- conditional expressions, Nesting Conditional Expressions
- expressions in XQuery, Subselects
- nil and empty values, Empty and nil values
- nilled elements, Relational Versus XML Data Models
- node tests, Node name tests, Node name tests, Node name tests and namespaces, Node kind tests
- node kind, Node kind tests
- node name, Node name tests, Node name tests and namespaces
- using wildcards, Node name tests and namespaces
- node( ) kind test, Node kind tests, Constructing Comments, Querying Processing Instructions, Querying Text Nodes
- processing instructions, Querying Processing Instructions
- text nodes, Querying Text Nodes
- XML comments, Constructing Comments
- node-name function, Node identity and name, Working with Qualified Names
- nodes, Nodes, The node hierarchy, The node hierarchy, Roots, documents, and elements, Node identity and name, Node identity and name, Atomic Values, General Comparisons, Value Comparisons, Document Order, Accepting arguments that are nodes versus atomic values, Nodes and Types, Atomization, Types and Newly Constructed Elements and Attributes, Working with Qualified Names, Using the xml:base attribute, XML Comments and the Data Model, Processing Instructions, Documents, Text Nodes
- atomic values, Atomic Values, General Comparisons
- comparisons, General Comparisons
- atomization, Atomization
- comment, XML Comments and the Data Model
- comparisons, Value Comparisons
- document, Documents
- document order, Document Order
- family relationships, The node hierarchy
- finding base URI, Using the xml:base attribute
- function arguments as, Accepting arguments that are nodes versus atomic values
- hierarchy, The node hierarchy
- identity and name, Node identity and name
- newly-constructed, content types and, Types and Newly Constructed Elements and Attributes
- processing instruction, Processing Instructions
- retrieving names, Working with Qualified Names
- roots, documents, and elements, Roots, documents, and elements
- string and typed values, Node identity and name
- text, Text Nodes
- types and, Nodes and Types
- D (nondecimal digit) character in regular expressions, Representing Groups of Characters
- nondecimal digit character (D), in regular expressions, Representing Groups of Characters
- S (nonwhitespace) character in regular expressions, Representing Groups of Characters
- W (nonword) character in regular expressions, Representing Groups of Characters
- nonword character (W) in regular expressions, Representing Groups of Characters
- normalize-space function, Normalizing Whitespace
- not equal to operator, General Comparisons, Value Comparisons, Comparing Numeric Values, Arithmetic Operations, Finding the time zone of a value, Comparisons
- !=, General Comparisons, Comparing Numeric Values, Finding the time zone of a value, Comparisons
- comparing dates and times, Finding the time zone of a value
- comparing numeric values, Comparing Numeric Values
- SQL and XQuery, Comparisons
- ne, Value Comparisons, Arithmetic Operations
- comparing numeric values, Arithmetic Operations
- not function, Negating a Boolean Value
- not operator, Full-Text Search, Boolean operators
- ! (full text not), Full-Text Search
- SQL, Boolean operators
- notations, XML, xs:NOTATION
- null values, Relational Versus XML Data Models
- numbers, FLWORs, The Built-in Types, Working with Numbers, The xs:decimal Type, Comparing Numeric Values, Arithmetic Operations, Division
- arithmetic operations on numeric values, Arithmetic Operations, Division
- division, Division
- comparing numeric values, Comparing Numeric Values
- in path expression predicates, FLWORs
- numeric types, Working with Numbers
- numeric keyword (in built-in function signatures), User-Defined Functions, Accepting arguments that are nodes versus atomic values
- numeric literals, Literals, The Numeric Types
- numeric-add operator, Built-in Versus User-Defined Functions
O
- occurrence indicators, User-Defined Functions, Accepting arguments that are nodes versus atomic values, Sequence Types, Sequence Types, Occurrence Indicators, Occurrence Indicators, Occurrence Indicators, Generic Sequence Types
- *, Sequence Types, Sequence Types, Occurrence Indicators
- in function argument types, Sequence Types
- specifying function return type, Sequence Types
- +, Occurrence Indicators
- ?, Occurrence Indicators
- empty sequence accepted as function arguments, Accepting arguments that are nodes versus atomic values
- indicating number of items in a sequence, User-Defined Functions
- using with sequence types, Generic Sequence Types
- generic sequence types, Generic Sequence Types
- operand expression, The Typeswitch Expression
- operators, Categories of Expressions, Keywords and Names, Evaluation Order and Parentheses, Comparison Expressions, Built-in Versus User-Defined Functions, Comparisons
- comparison, Comparison Expressions
- evaluation order and parentheses, Evaluation Order and Parentheses
- Functions and Operators recommendation, Built-in Versus User-Defined Functions
- listed, Categories of Expressions
- multiple meanings in XQuery, Keywords and Names
- SQL and XQuery, Comparisons
- optimization, implementations of XSLT and XQuery, Optimization for particular use cases
- option declarations, Prolog Declarations, Option Declarations and Extension Expressions
- optional features (XQuery), Conformance
- or operator, Logical (and/or) Expressions, Full-Text Search, Arithmetic and string operators
- SQL and XQuery, Arithmetic and string operators
- || (full text or), Full-Text Search
- order by clause (FLWORs), Adding XML Elements and Attributes, Sorting in XQuery, Using multiple ordering specifications, Sorting and types, Order modifiers, Stable ordering, More complex order specifications, Inadvertent resorting in document order
- complex order specifications, More complex order specifications
- inadvertent resorting in document order, Inadvertent resorting in document order
- multiple ordering specifications, Using multiple ordering specifications
- order modifiers, Order modifiers
- stable ordering, Stable ordering
- types, Sorting and types
- order.xml document (example), Easing into XQuery
- ordered expressions, Grouping
- ordering mode declaration, The ordering mode declaration
- outermost element, Roots, documents, and elements
- outermost element node, document node vs., Documents
P
- parameters, Serialization, Specifying Serialization Parameters
- serialization, Serialization, Specifying Serialization Parameters
- specifying in different XQuery implementations, Specifying Serialization Parameters
- parent (nodes), Roots, documents, and elements
- ( ) (parentheses), Function Calls, Evaluation Order and Parentheses, General comparisons and types, Conditional (if-then-else) Expressions, Argument Lists, Argument lists and sequences, Combining Results, Choosing Names, Representing Any Character, Using Flags, Querying Comments
- (: :) (XQuery comment delimiters), Function Calls, Querying Comments
- concatenating sequences with sequence constructor, Combining Results
- empty sequence as argument in function call, Argument lists and sequences
- enclosing test expression after if keyword, Conditional (if-then-else) Expressions
- escaping in regular expressions, Representing Any Character
- evaluation order and, Evaluation Order and Parentheses
- in functions, Argument Lists
- interaction with commas and curly braces in XQuery, General comparisons and types
- sub-expressions and branches in regular expressions, Using Flags
- using for query clarity, Choosing Names
- path expressions, Path Expressions, Categories of Expressions, Navigating Input Documents Using Paths, Steps, Axes, Node name tests, Node kind tests, Dynamic Paths, Selecting with Path Expressions, Selecting with Path Expressions, Sorting in XQuery, Combining Results, Names affected by namespace declarations, Sequence Types and Schemas, Querying Text Nodes
- abbreviated syntax, Node kind tests
- axes, Axes
- combining sequences via unions, Combining Results
- dynamic paths, Dynamic Paths
- element names in XQuery, affected by default namespace declaration, Names affected by namespace declarations
- FLWORs vs., Selecting with Path Expressions
- kind tests, Sequence Types and Schemas
- node tests, Node name tests
- querying text nodes, Querying Text Nodes
- results returned in document order, Sorting in XQuery
- selecting elements from input documents, Selecting with Path Expressions
- steps, Steps
- % (percent sign), Finding the URI of a document, Built-in Functions
- separator character in URIs, Finding the URI of a document
- URI characters escaped for HTML agents, Built-in Functions
- . (period), A Closer Look at Context, Recursive Functions, Representing Individual Characters, Representing Any Character, Using Flags
- abbreviation for context item, Recursive Functions
- character wildcard in regular expressions, Representing Any Character
- escaping in regular expressions, Representing Individual Characters
- representing context node in predicates and paths, A Closer Look at Context
- wildcard, dot-all mode, Using Flags
- pessimistic static typing, What Is Static Typing?, The Treat Expression
- pipelining, Reducing Complexity
- + (plus sign), User-Defined Functions, Arithmetic Operations, Representing Any Character, Adding and Subtracting Durations from Dates and Times, Adding and Subtracting Two Durations, Finding the URI of a document
- addition operator, Arithmetic Operations, Adding and Subtracting Durations from Dates and Times, Adding and Subtracting Two Durations
- adding durations, Adding and Subtracting Two Durations
- adding durations to dates and times, Adding and Subtracting Durations from Dates and Times
- escaping in regular expressions, Representing Any Character
- occurrence indicator, one or many items, User-Defined Functions
- separator character in URIs, Finding the URI of a document
- position function, The position and last functions, Adding Sequence Numbers to Results
- positions, Using Positions in Predicates, Working with Positions and Sequence Numbers
- using in predicates, Using Positions in Predicates
- positive infinity (INF), Arithmetic Operations
- # (pound sign), delimiters for extension expression pragmas, Extension Expressions
- precedence, Evaluation Order and Parentheses, Evaluation Order of Logical Expressions
- evaluation order of expressions, Evaluation Order and Parentheses
- logical operators, Evaluation Order of Logical Expressions
- preceding axis, Conformance
- preceding-sibling axis, Conformance
- predicates, Path Expressions, Predicates, Positional predicates and reverse axes, More Complex Predicates, Joins
- complex, More Complex Predicates
- two-way join in FLWOR predicate, Joins
- using multiple, Positional predicates and reverse axes
- prefixes, namespace, Namespaces and Attributes, Namespaces and XQuery, Namespace Declarations in Queries, Other prolog namespace declarations, Other Name-Related Functions
- attributes, Namespaces and Attributes
- functions for, Other Name-Related Functions
- overriding default namespace, Namespaces and XQuery
- predeclared, Namespace Declarations in Queries
- schema imports, module declarations, and module imports, Other prolog namespace declarations
- prices.xml document (example), Easing into XQuery
- primary expressions, Categories of Expressions
- primitive types, The Built-in Types, Casting among the primitive types, Casting among the primitive types
- casting among, Casting among the primitive types, Casting among the primitive types
- xs:string and xs:untypedAtomic, Casting among the primitive types
- processing instruction nodes, The node hierarchy
- processing instructions (XML), Processing Instructions
- processing model for XQuery, Processing Queries, Processing Queries, XML Input Documents, The Context, The Query Processor, The Results of the Query
- context, The Context
- queries, XML Input Documents
- query processor, The Query Processor
- query results, The Results of the Query
- XML input documents, Processing Queries
- product catalog input document (catalog.xml), Easing into XQuery
- prolog, queries, Predeclared Namespaces, Default namespace declarations in the prolog, Scope of namespace declarations, Controlling Namespace Declarations in Your Results, Structure of a Query: Prolog and Body, The Version Declaration, Assembling Queries from Multiple Modules
- main module, Assembling Queries from Multiple Modules
- namespace declarations, Predeclared Namespaces, Default namespace declarations in the prolog, Scope of namespace declarations, Controlling Namespace Declarations in Your Results
- controlling in query results, Controlling Namespace Declarations in Your Results
- default namespaces, Default namespace declarations in the prolog
- scope of, Scope of namespace declarations
- version declaration, The Version Declaration
- promotion, type, Numeric Type Promotion
- numeric, Numeric Type Promotion
- pull stylesheets, Paradigm differences: push versus pull, Paradigm differences: push versus pull, Paradigm differences: push versus pull
- equivalent in XQuery, Paradigm differences: push versus pull
- use on narrative content (example), Paradigm differences: push versus pull
- push stylesheets, Paradigm differences: push versus pull
Q
- qualified names, Names of computed element constructors, Working with Qualified Names, URIs, and IDs, Working with Qualified Names, Extension Expressions, xs:NOTATION
- computed element constructors, Names of computed element constructors
- options, Extension Expressions
- retrieving node names, Working with Qualified Names
- xs:QName type, xs:NOTATION
- quantified expressions, Keywords and Names, Quantified Expressions, Sequence Type Matching, Type Declarations in FLWORs
- sequence type matching, Sequence Type Matching
- type declarations, Type Declarations in FLWORs
- quantifiers, Regular Expressions, Character Class Expressions
- regular expression, Regular Expressions
- using with regular expression character class expressions, Character Class Expressions
- queries, Easing into XQuery, XML Input Documents, The Context, The Context, The Query Processor, Namespaces, Keywords and Names, Namespaces and XQuery, Predeclared Namespaces, Controlling Namespace Declarations in Your Results, Queries, Prologs, and Modules, Structure of a Query: Prolog and Body, The Version Declaration, Library Modules, Variable Declarations, Variable Declaration Syntax, Variable Names, External Variables, Declaring External Functions, Why Use Schemas with Queries?, Query Design Goals, Clarity, Modularity, Modularity, Error Handling, Performance, Comparing SQL Syntax with XQuery Syntax, SQL/XML, Equivalent Components
- assembling from multiple modules, Library Modules
- comparing SQL to XQuery, Comparing SQL Syntax with XQuery Syntax
- context, The Context
- design goals, Query Design Goals, Clarity, Modularity, Modularity, Error Handling, Performance
- clarity, Clarity
- error handling, Error Handling
- modularity, Modularity
- performance, Performance
- robustness, Modularity
- examples, Easing into XQuery
- external variables, External Variables
- namespace declarations, Predeclared Namespaces, Controlling Namespace Declarations in Your Results
- controlling in results, Controlling Namespace Declarations in Your Results
- namespace-qualified names, uses of, Namespaces and XQuery
- namespaces, using, Namespaces
- processor, The Context
- prolog and body, Structure of a Query: Prolog and Body
- prolog declarations, The Version Declaration, Variable Declaration Syntax, Declaring External Functions
- external functions, Declaring External Functions
- variable declarations, Variable Declaration Syntax
- version declaration, The Version Declaration
- results, The Query Processor
- schemas, advantages of using, Why Use Schemas with Queries?
- SQL/XML query, SQL/XML
- syntax, XQuery vs. XSLT, Equivalent Components
- variables, Variable Declarations, Variable Names
- names of, Variable Names
- scope, Variable Declarations
- whitespace in, Keywords and Names
- ? (question mark), User-Defined Functions, Accepting arguments that are nodes versus atomic values, Function Conversion Rules, Representing Individual Characters, Finding the URI of a document
- escaping in regular expressions, Representing Individual Characters
- occurrence indicator (zero or one items), User-Defined Functions, Accepting arguments that are nodes versus atomic values, Function Conversion Rules
- in function argument types, Function Conversion Rules
- separator character in URIs, Finding the URI of a document
- " (quotes, double), Literals, The xs:string Type, XML Entity and Character References
- enclosing string literals, Literals
- entity reference ("), XML Entity and Character References
- string literals included in queries, The xs:string Type
- ' (quotes, single), Literals, The xs:string Type, XML Entity and Character References
- enclosing string literals, Literals
- entity reference ('), XML Entity and Character References
- string literals included in queries, The xs:string Type
R
- recursion, Why Define Your Own Functions?
- references, Representing Individual Characters, Back-References, Working with URIs, Working with URIs, Working with IDs, XML Entity and Character References
- back-references, Back-References
- character, XML Entity and Character References
- IDREFs, Working with IDs
- parenthesized sub-expressions in regular expressions, Representing Individual Characters
- URI, Working with URIs, Working with URIs
- relative URIs, Working with URIs
- xs:anyURI, Working with URIs
- regular expressions (and pattern-matching), Matching a String to a Pattern, Replacing Substrings That Match a Pattern, The Structure of a Regular Expression, The Structure of a Regular Expression, The Structure of a Regular Expression, The Structure of a Regular Expression, Representing Individual Characters, Representing Individual Characters, Representing Any Character, Representing Groups of Characters, Representing Groups of Characters, Category Escapes, Character Class Expressions, Character Class Expressions, Character Class Expressions, Negative Character Class Expressions, Negative Character Class Expressions, Escaping Rules for Character Class Expressions, Reluctant Quantifiers, Anchors, Back-References, Using Flags, Using Sub-Expressions with Replacement Variables, Comparisons
- anchors, Anchors
- back-references, Back-References
- character class expressions, Character Class Expressions, Character Class Expressions, Negative Character Class Expressions, Negative Character Class Expressions, Escaping Rules for Character Class Expressions
- escaping rules, Escaping Rules for Character Class Expressions
- examples, Negative Character Class Expressions
- negative character class, Negative Character Class Expressions
- single characters and ranges, Character Class Expressions
- flags, using, Using Flags
- matching string to a pattern, Matching a String to a Pattern
- reluctant quantifiers, Reluctant Quantifiers
- replacing substrings matching a pattern, Replacing Substrings That Match a Pattern
- representing any character in regular expressions with . (period), Representing Any Character
- representing groups of characters, Representing Groups of Characters, Representing Groups of Characters, Category Escapes, Character Class Expressions
- category escapes, Category Escapes
- examples of multi-character, category and block escapes, Character Class Expressions
- multi-character escapes, Representing Groups of Characters
- representing individual characters, Representing Individual Characters, Representing Individual Characters
- single-character escapes, Representing Individual Characters
- SQL LIKE conditions vs., Comparisons
- structure of regular expressions, The Structure of a Regular Expression, The Structure of a Regular Expression, The Structure of a Regular Expression
- atoms, The Structure of a Regular Expression
- quantifiers, The Structure of a Regular Expression
- sub-expressions with replacement variables, Using Sub-Expressions with Replacement Variables
- relational databases, Uses for XQuery, Easing into XQuery, Relational Versus XML Data Models, Combining SQL and XQuery
- native XML databases vs., Uses for XQuery
- supporting XML and XQuery, Easing into XQuery
- XML data model vs., Relational Versus XML Data Models
- XQuery support in, Combining SQL and XQuery
- relative URIs, Working with URIs, The base URI of the static context
- resolving URIs, The base URI of the static context
- reluctant quantifiers, Reluctant Quantifiers
- remainder after dividing (modulus), Arithmetic Operations
- replace function, Replacing Substrings That Match a Pattern, Representing Individual Characters, Representing Any Character, Anchors, Using Flags, Using Sub-Expressions with Replacement Variables
- back-references and variable references, Representing Individual Characters
- dot-all mode, Representing Any Character
- flags, Using Flags
- reluctant and non-reluctant quantifiers, Anchors
- sub-expressions with replacement variables, Using Sub-Expressions with Replacement Variables
- replace-first function, Whitespace and Strings
- resolve-uri function, The base URI of the static context, The base URI of the static context
- base URI of the static context, The base URI of the static context
- return clause (FLWORs), Adding XML Elements and Attributes, FLWOR Expressions, Quantified Expressions
- scope of variables, Quantified Expressions
- reverse axes, positional predicates and, Positional predicates and reverse axes
- reverse steps, Steps
- axis, Steps
- robustness of queries, Modularity, Modularity
- data variations, handling, Modularity
- root element, Roots, documents, and elements
- root node, Roots, documents, and elements
- round function, Functions on Numbers
- round-half-to-even function, Functions on Numbers
S
- s option ($flags argument), indicating dot-all mode, Using Flags
- satisfies (keyword), Keywords and Names
- Saxon, Processing Scenarios, Option Declarations and Extension Expressions
- option declarations, Option Declarations and Extension Expressions
- schema-attribute( ) kind test, Sequence Types and Schemas
- schema-element( ) kind test, Sequence Types and Schemas
- schemas, XQuery Versus SQL, Node kind tests, Multiple module imports, Using Schemas with XQuery, Using Schemas with XQuery, Why Use Schemas with Queries?, W3C XML Schema: A Brief Overview, W3C XML Schema: A Brief Overview, In-Scope Schema Definitions, Schema Imports, Schema Validation and Type Assignment, The Validate Expression, Validation Mode, Sequence Types and Schemas, Conformance
- defined, Using Schemas with XQuery
- importing, Multiple module imports
- imports, Schema Imports
- in-scope schema definitions (ISSDs), In-Scope Schema Definitions
- node kind tests for elements and attributes, Node kind tests
- reasons to use with queries, Why Use Schemas with Queries?
- sequence types and, Sequence Types and Schemas
- support for schema imports and validation, Conformance
- validation and type assignment, Schema Validation and Type Assignment, The Validate Expression, Validation Mode
- validate expression, The Validate Expression
- validation mode, Validation Mode
- W3C XML Schema, XQuery Versus SQL, W3C XML Schema: A Brief Overview, W3C XML Schema: A Brief Overview
- types, W3C XML Schema: A Brief Overview
- scope, The Impact and Scope of Namespace Declarations, In-Scope Versus Statically Known Namespaces, Variable Declarations, Built-in Function Reference
- in-scope namespaces, In-Scope Versus Statically Known Namespaces, Built-in Function Reference
- namespace declarations in XQuery, The Impact and Scope of Namespace Declarations
- variables, Variable Declarations
- searches, full text, XQuery Update Facility
- seconds, Extracting Components of Dates, Times, and Durations
- extracting from dates, times, and durations, Extracting Components of Dates, Times, and Durations
- ; (semicolon), Prolog Declarations, Finding the URI of a document
- separator character in URIs, Finding the URI of a document
- terminating declarations in query prolog, Prolog Declarations
- separator characters (URI), escaping, Finding the URI of a document
- sequence constructors, Combining Results
- sequence numbers, Working with Positions and Sequence Numbers, Working with Positions and Sequence Numbers
- adding to results, Working with Positions and Sequence Numbers
- sequence types, User-Defined Functions, Accepting arguments that are nodes versus atomic values, Sequence Types, Generic Sequence Types, Sequence Type Matching, Sequence Types and Schemas, Sequence Types and Schemas, Sequence Types and Schemas
- function parameters as, User-Defined Functions
- generic, Generic Sequence Types
- matching, Sequence Type Matching
- schemas and, Sequence Types and Schemas, Sequence Types and Schemas, Sequence Types and Schemas
- element and attribute tests, Sequence Types and Schemas
- examples based on name and type, Sequence Types and Schemas
- sequence-related expressions, Keywords and Names
- sequences, Sequences, Sequences, Sequences, Categories of Expressions, Literals, General comparisons on multi-item sequences, Argument lists and sequences, Combining Results
- argument lists and, Argument lists and sequences
- combining result sequences, Combining Results
- empty, Sequences
- expression evaluation to, Categories of Expressions
- multi-item, general comparisons on, General comparisons on multi-item sequences
- singleton, Sequences
- variables bound to particular value, Literals
- serialization, The Results of the Query, Serialization, Serialization, Conformance, Option Declarations and Extension Expressions, Specifying Serialization Parameters
- errors, Serialization
- query results to XML document, support for, Conformance
- specifying parameters for saxon:output, Option Declarations and Extension Expressions
- specifying parameters in different XQuery implementations, Specifying Serialization Parameters
- set operators (SQL), Subselects
- set-string-to-length function, Concatenating and Splitting Strings
- siblings (nodes), Roots, documents, and elements, Conformance, Conformance
- following siblings, Conformance
- preceding siblings, Conformance
- side effects of functions, Declaring External Functions
- signatures (function), User-Defined Functions
- numeric keyword used by built-in functions, User-Defined Functions
- simple types, The Built-in Types, Simple and complex types
- built-in, The Built-in Types
- singleton sequence, Sequences
- / (slash), Path Expressions, FLWORs, A Closer Look at Context, Accessing the Root, Finding the URI of a document
- beginning path expressions, Path Expressions, FLWORs, Accessing the Root
- // (double slash), FLWORs
- in predicates, changing context node, A Closer Look at Context
- URI separator character, Finding the URI of a document
- some (keyword), Keywords and Names
- sort key, parameterizing, Document Order
- sorting, Sorting and Grouping, Sorting in XQuery, Using multiple ordering specifications, Sorting and types, Order modifiers, Stable ordering, More complex order specifications, Document Order, Inadvertent resorting in document order, The unordered function, The unordered expression, Grouping, Constraining and Sorting on Aggregated Values, Comparing SQL Syntax with XQuery Syntax
- document order, Document Order, Inadvertent resorting in document order
- inadvertent resorting in, Inadvertent resorting in document order
- indicating order is not significant, The unordered function, The unordered expression
- unordered expression, The unordered expression
- unordered function, The unordered function
- indicating whether order is significant, Grouping
- on aggregated values, Constraining and Sorting on Aggregated Values
- order by clause (FLWORs), Sorting in XQuery, Using multiple ordering specifications, Sorting and types, Order modifiers, Stable ordering, More complex order specifications
- complex order specifications, More complex order specifications
- multiple ordering specifications, Using multiple ordering specifications
- order modifiers, Order modifiers
- stable ordering, Stable ordering
- types, Sorting and types
- SQL vs. XQuery query results, Comparing SQL Syntax with XQuery Syntax
- s (space) character in regular expressions, Representing Groups of Characters
- splitting strings, Concatenating and Splitting Strings
- SQL users, XQuery for, Relational Versus XML Data Models, Relational Versus XML Data Models, Comparing SQL Syntax with XQuery Syntax, A Simple Query, Conditions and Operators, Functions, Subselects, Combining SQL and XQuery, Combining SQL and XQuery
- combining SQL and XQuery, Combining SQL and XQuery, Combining SQL and XQuery
- structured and semistructured data, Combining SQL and XQuery
- comparison of SQL to XQuery syntax, Comparing SQL Syntax with XQuery Syntax, A Simple Query, Conditions and Operators, Functions, Subselects
- conditions and operators, Conditions and Operators
- functions, Functions
- grouping, Subselects
- simple query, A Simple Query
- relational vs. XML data models, Relational Versus XML Data Models
- SQL/XML, SQL/XML
- [ ] (square brackets), FLWORs, Predicates, A Closer Look at Context, Representing Any Character, Character Class Expressions, Finding the URI of a document
- character classes in regular expressions, Character Class Expressions
- escaping in regular expressions, Representing Any Character
- in predicates, FLWORs, Predicates, A Closer Look at Context
- changing context node, A Closer Look at Context
- separator character in URIs, Finding the URI of a document
- stable ordering, Stable ordering
- standards related to XQuery, Serialization, Serialization, Serialization, XQueryX, XQuery Update Facility, XQuery Update Facility, XQuery API for Java (XQJ)
- full-text search, XQuery Update Facility
- serialization, Serialization, Serialization
- parameters, Serialization
- Update Facility (W3C) for XQuery, XQuery Update Facility
- XQJ (XQuery API for Java), XQuery API for Java (XQJ)
- XQueryX, XQueryX
- static analysis phase (type checking), Type Checking in XQuery
- static context, The base URI of the static context
- static typing, Static Typing, Raising "False" Errors, The Typeswitch Expression, The Treat Expression, Type Declarations, Conformance
- detection of all errors in analysis phase, Conformance
- expressions and constructs, Raising "False" Errors
- treat expression, The Treat Expression
- type declarations, Type Declarations
- typeswitch expression, The Typeswitch Expression
- static-base-uri function, The base URI of the static context
- statically known namespaces vs. in-scope namespaces, Controlling Namespace Declarations in Your Results
- steps, Steps, Node kind tests
- abbreviated syntax, Node kind tests
- string literals, Literals
- string value (nodes), Node identity and name
- string-join function, Concatenating and Splitting Strings
- string-length function, Finding the Length of a String
- string-to-codepoints function, Concatenating and Splitting Strings
- strings, The Built-in Types, Working with Strings, Working with Strings, The xs:string Type, Constructing Strings, Comparing Strings, Finding the Length of a String, Concatenating and Splitting Strings, Whitespace and Strings, Internationalization Considerations, Unicode Normalization, xs:NMTOKEN, xs:string
- comparing, Comparing Strings
- concatenating and splitting, Concatenating and Splitting Strings
- constructing, Working with Strings, Constructing Strings
- string literals, Constructing Strings
- finding length, Finding the Length of a String
- internationalization, Internationalization Considerations, Unicode Normalization
- collations, Internationalization Considerations
- Unicode normalization, Unicode Normalization
- whitespace, Whitespace and Strings
- xs:normalizedString type, xs:NMTOKEN
- xs:string type, The xs:string Type, xs:string
- stylesheets, XSLT, Paradigm differences: push versus pull, Paradigm differences: push versus pull, Paradigm differences: push versus pull, Paradigm differences: push versus pull, Paradigm differences: push versus pull, Paradigm differences: push versus pull, Paradigm differences: push versus pull
- pull stylesheets, Paradigm differences: push versus pull, Paradigm differences: push versus pull, Paradigm differences: push versus pull
- attempt to use on narrative content, Paradigm differences: push versus pull
- XQuery equivalent, Paradigm differences: push versus pull
- push stylesheets, Paradigm differences: push versus pull, Paradigm differences: push versus pull, Paradigm differences: push versus pull
- use on narrative content, Paradigm differences: push versus pull
- XQuery user-defined functions emulating templates, Paradigm differences: push versus pull
- subexpressions, Enclosed expressions that evaluate to attributes, Using Sub-Expressions with Replacement Variables
- multiple, in enclosed expressions, Enclosed expressions that evaluate to attributes
- using with replacement variables, Using Sub-Expressions with Replacement Variables
- subselects (SQL), Subselects
- substitution groups, Sequence Types and Schemas
- substring function, Function Signatures
- signatures, Function Signatures
- substring-after function, Finding the Length of a String
- substring-after-last function, Finding the Length of a String
- substring-before function, Finding the Length of a String
- subtraction, Arithmetic Operations, Precedence of Arithmetic Operators, Using Arithmetic Operators on Dates, Times, and Durations, Adding and Subtracting Durations from Dates and Times, Adding and Subtracting Two Durations, Arithmetic and string operators
- dates and times, Using Arithmetic Operators on Dates, Times, and Durations
- durations, Adding and Subtracting Two Durations
- durations from dates and times, Adding and Subtracting Durations from Dates and Times
- SQL and XQuery operators, Arithmetic and string operators
- subtraction operator (-), Arithmetic Operations
- subtype substitution, Subtype Substitution, Numeric Type Promotion
- sum function, Aggregating and Grouping Values, Aggregating Values, Functions on Numbers
T
- (tab character), in regular expressions, Representing Any Character
- tabs, escaping in regular expressions, Representing Any Character
- templates (XSLT), Paradigm differences: push versus pull, Paradigm differences: push versus pull
- emulating in XQuery with user-defined functions, Paradigm differences: push versus pull
- use by push stylesheets, Paradigm differences: push versus pull
- test expression (after if keyword), Conditional (if-then-else) Expressions
- text nodes, The node hierarchy, Text Nodes
- text, full-text searches, XQuery Update Facility
- then keyword, Conditional (if-then-else) Expressions
- time zones, Time Zones, Adjusting time zones, Finding the time zone of a value, Finding the time zone of a value, The Duration Types
- adjusting, Adjusting time zones
- date and time comparisons, The Duration Types
- finding for xs:date, xs:time, or xs:dateTime values, Finding the time zone of a value
- timezone-from-time function, Finding the time zone of a value
- to (keyword), The position and last functions, Multiple for clauses
- in positional predicates, The position and last functions
- in range expressions, Multiple for clauses
- tokenize function, Concatenating and Splitting Strings, Splitting Strings Apart, Representing Any Character, Using Flags
- dot-all mode, Representing Any Character
- flags, Using Flags
- treat expression, The Treat Expression
- true function, Literals
- two-way joins, Joins
- in FLWOR predicate, Joins
- type errors, Type Checking in XQuery
- type promotion, Numeric Type Promotion, Working with URIs
- numeric, Numeric Type Promotion
- xs:anyURI values to xs:string, Working with URIs
- type-related expressions, Keywords and Names
- typed values, String and typed values of nodes
- types, Types, Namespaces, Literals, General comparisons on multi-item sequences, Using multiple ordering specifications, User-Defined Functions, Namespaces and XQuery, Namespaces and XQuery, Namespace Declarations in Queries, Names affected by namespace declarations, A Closer Look at Types, The XQuery Type System, The Built-in Types, Type Checking in XQuery, Constructors and Casting, Constructors, The Castable Expression, Casting among the primitive types, W3C XML Schema: A Brief Overview, W3C XML Schema: A Brief Overview, List types, Type Declarations, Working with Numbers, Working with Dates, Times, and Durations, Time Zones, The yearMonthDuration and dayTimeDuration Types, xs:anyAtomicType
- built-in, Namespaces and XQuery, The Built-in Types, W3C XML Schema: A Brief Overview, xs:anyAtomicType
- reference, xs:anyAtomicType
- checking in XQuery, Type Checking in XQuery
- conversions, Literals, User-Defined Functions, Constructors and Casting, Constructors, The Castable Expression, Casting among the primitive types
- castable expression, The Castable Expression
- casting, Constructors
- casting rules, Casting among the primitive types
- constructors, using, Literals, Constructors and Casting
- function arguments to expected type, User-Defined Functions
- date and time, Working with Dates, Times, and Durations, Time Zones, The yearMonthDuration and dayTimeDuration Types
- duration types, The yearMonthDuration and dayTimeDuration Types
- time zones, Time Zones
- declarations, Type Declarations
- general comparisons and, General comparisons on multi-item sequences
- generic types used when no schema is present, W3C XML Schema: A Brief Overview
- list, List types
- names affected by namespace declarations in XQuery, Names affected by namespace declarations
- namespaces, Namespaces, Namespace Declarations in Queries
- predeclared, Namespace Declarations in Queries
- numeric, Working with Numbers
- sorting and, Using multiple ordering specifications
- strong type system, advantages and disadvantages, The XQuery Type System
- user-defined, Namespaces and XQuery
- typeswitch expression, Sequence Type Matching, The Typeswitch Expression
- typeswitch keyword, The Typeswitch Expression
U
- undeclaring default namespace, Namespaces and XQuery
- Unicode, Unicode Normalization, Category Escapes, Block Escapes, XML Version Support
- block names, Block Escapes
- categories of characters, Category Escapes
- normalization, Unicode Normalization
- version support in XQuery implementations, XML Version Support
- Uniform Resource Names (URNs), XML Namespaces
- union keyword, Combining Results
- union operator (|), Combining Results
- unordered expression, Conformance
- implementation-dependency of order of results, Conformance
- unordered expressions, The unordered function
- unordered function, The unordered function
- unprefixed element, Retrieving Node Names
- untyped values, Atomic Values, Atomic Values and Types, xs:untyped, xs:untypedAtomic
- atomic values, Atomic Values, Atomic Values and Types, xs:untypedAtomic
- xs:untyped, xs:untyped
- Update Facility for XQuery, XQuery Update Facility
- upper-case function, Function Signatures, Argument lists and sequences
- empty sequence as argument, Argument lists and sequences
- signature, Function Signatures
- URIs (Uniform Resource Identifiers), Namespaces, Namespace URIs, Default namespace declarations in the prolog, Working with URIs, Working with URIs, Working with URIs, Using the xml:base attribute, Using the xml:base attribute, The base URI of the static context, The base URI of the static context, Finding the URI of a document, Finding the URI of a document, xs:anyURI
- base and relative, Working with URIs, Using the xml:base attribute, Using the xml:base attribute, The base URI of the static context, The base URI of the static context
- base URI of the static context, The base URI of the static context
- finding base URI of a node, Using the xml:base attribute
- resolving URIs, The base URI of the static context
- specifying base URI with xml:base attribute, Using the xml:base attribute
- documents and, Finding the URI of a document
- escaping, Finding the URI of a document
- namespace, Namespaces, Namespace URIs, Default namespace declarations in the prolog
- prolog declarations, Default namespace declarations in the prolog
- references (xs:anyURI), Working with URIs
- xs:anyURI type, xs:anyURI
- URLs (Uniform Resource Locators), Working with URIs
- URNs (Uniform Resource Names), XML Namespaces, Working with URIs
- user-defined functions, Built-in Versus User-Defined Functions, User-Defined Functions, User-Defined Functions, Function Declarations, Function Declarations, The Function Name, The Parameter List, Recursive Functions
- body, Function Declarations
- built-in vs., Built-in Versus User-Defined Functions
- declarations, Function Declarations
- examples, User-Defined Functions
- names, The Function Name
- parameter list, The Parameter List
- recursive, Recursive Functions
- user-defined types, The Built-in Types, User-defined types
- UTC (Coordinated Universal Time), The Duration Types
- date and time comparisons, The Duration Types
V
- validate expression, The Validate Expression, Text Nodes, Conformance
- support for, Conformance
- validation modes, Validation Mode
- value comparisons, Value Comparisons, Arithmetic Operations
- comparing numeric values, Arithmetic Operations
- value space, The Built-in Types, Casting among the primitive types, Casting among derived types
- casting among derived types, Casting among derived types
- casting among primitive types, Casting among the primitive types
- variables, Adding XML Elements and Attributes, Namespaces, Literals, Quantified Expressions, Aggregating Values, Namespaces and XQuery, Names affected by namespace declarations, Variable Declarations, Variable Declarations, Variable Names, External Variables, External Variables, The Typeswitch Expression, Using Sub-Expressions with Replacement Variables
- binding entire sequence of items in FLWOR let clause, Aggregating Values
- binding to typeswitch expressions, The Typeswitch Expression
- declaring, Variable Declarations
- external, External Variables
- imported from modules, External Variables
- names, Variable Names
- names affected by namespace declarations in XQuery, Names affected by namespace declarations
- namespaces, Namespaces
- qualified names in queries, Namespaces and XQuery
- replacement, using with subexpressions, Using Sub-Expressions with Replacement Variables
- scope, Quantified Expressions, Variable Declarations
- setting values with let clause in expressions, Adding XML Elements and Attributes
- version declaration, The Version Declaration
- versions, XML version support in XQuery implementations, XML Version Support
- | (vertical bar), Other Expressions As Steps, Combining Results, Representing Individual Characters, Using Flags, Full-Text Search
- between branches in regular expressions, Using Flags
- escaping in regular expressions, Representing Individual Characters
- union operator, Other Expressions As Steps, Combining Results
- || (or) operator, Full-Text Search
W
- W3C, XML Namespaces, XQuery Update Facility, XQuery Update Facility, Full-Text Search
- converter for XQuery to XqueryX conversions, XQuery Update Facility
- Namespaces in XML, XML Namespaces
- XQuery Working Group, XQuery Update Facility, Full-Text Search
- Full-Text recommendation, Full-Text Search
- XQuery Update Facility, XQuery Update Facility
- web sites, User-Defined Functions, Convenient features of XSLT
- backward compatibility between XPath 1.0 and 2.0, Convenient features of XSLT
- user-defined function examples, User-Defined Functions
- weight keyword, XQuery API for Java (XQJ)
- where clause (FLWORs), Adding XML Elements and Attributes, FLWOR Expressions, Quantified Expressions
- scope of variables, Quantified Expressions
- whitespace, Whitespace in Queries, Direct Element Constructors and Whitespace, Boundary whitespace, The boundary-space declaration, Forcing boundary whitespace preservation, Finding the Length of a String, Whitespace and Strings, Representing Individual Characters, Representing Groups of Characters, Using Sub-Expressions with Replacement Variables
- in direct element constructors, Direct Element Constructors and Whitespace, Boundary whitespace, The boundary-space declaration, Forcing boundary whitespace preservation
- boundary whitespace, Boundary whitespace
- boundary-space declaration, The boundary-space declaration
- forcing preservation of boundary whitespace, Forcing boundary whitespace preservation
- in regular expressions, Representing Individual Characters, Representing Groups of Characters, Using Sub-Expressions with Replacement Variables
- escaping, Representing Individual Characters, Representing Groups of Characters
- ignoring, Using Sub-Expressions with Replacement Variables
- in strings, Finding the Length of a String, Whitespace and Strings
- considering in string length, Finding the Length of a String
- wildcards, FLWORs, Node name tests and namespaces
- asterisk (*) in path expressions, FLWORs
- using in node name tests, Node name tests and namespaces
- w (word) character in regular expressions, Representing Groups of Characters
- word character (w) in regular expressions, Representing Groups of Characters
X
- x option ($flags argument), indicating ignoring whitespace characters, Using Sub-Expressions with Replacement Variables
- XML, Processing Queries, Function Calls, Namespaces and XQuery, Default Namespace Declarations, Namespace Declarations and Scope, In-Scope Versus Statically Known Namespaces, Working with Other XML Components, XML Comments, Processing Instructions, Documents, Text Nodes, XML Entity and Character References, CDATA Sections, Conformance, XML Version Support, Relational Versus XML Data Models, SQL/XML, xs:NOTATION
- CDATA sections, CDATA Sections
- comments, Function Calls, Working with Other XML Components, XML Comments
- data model and, XML Comments
- included in queries, Function Calls
- data model, relational vs., Relational Versus XML Data Models
- documents, Documents, Conformance
- serialization of query results to, Conformance
- entity and character references, XML Entity and Character References
- entity references, XML Entity and Character References
- input documents, Processing Queries
- namespaces, Namespaces and XQuery, Default Namespace Declarations, Namespace Declarations and Scope, In-Scope Versus Statically Known Namespaces
- declarations and scope, Namespace Declarations and Scope
- default namespace declarations, Default Namespace Declarations
- using namespace declarations in XQuery, In-Scope Versus Statically Known Namespaces
- notations, xs:NOTATION
- processing instructions, Processing Instructions
- SQL/XML query, SQL/XML
- text nodes, Text Nodes
- version support in XQuery implementations, XML Version Support
- xml namespace, Namespace Declarations in Queries
- XML Schema, XQuery and XML Schema, Types, W3C XML Schema: A Brief Overview, W3C XML Schema: A Brief Overview, User-defined types, Sequence Types and Schemas, Relational Versus XML Data Models
- nilled elements concept, Relational Versus XML Data Models
- substitution groups, Sequence Types and Schemas
- type system, Types
- types, W3C XML Schema: A Brief Overview, User-defined types
- user-defined, User-defined types
- XML Schema Namespace, Namespaces and XQuery
- XML-qualified names, Keywords and Names, Literals
- variables, Literals
- xml:base attribute, Using the xml:base attribute
- xml:id attribute, Working with IDs
- xmlns prefix (namespace attribute), Namespaces
- XPath, XQuery in Context, The XQuery Data Model, Roots, documents, and elements, XQuery for XSLT Users, Convenient features of XSLT, Convenient features of XSLT, Data Model, New Expressions, Path Expressions, Arithmetic and Comparison Expressions, Built-in Functions
- backward incompatibility between 1.0 and 2.0, web site information, Convenient features of XSLT
- differences in versions 1.0 and 2.0, Convenient features of XSLT, Data Model, New Expressions, Path Expressions, Arithmetic and Comparison Expressions, Built-in Functions
- built-in functions, Built-in Functions
- data model, Data Model
- function conversion rules, Arithmetic and Comparison Expressions
- new expressions, New Expressions
- path expressions, Path Expressions
- document element (XPath 1.0), Roots, documents, and elements
- XPath 2.0 Data Model, The XQuery Data Model
- XQuery and, XQuery for XSLT Users
- XPath Datatypes Namespace, The yearMonthDuration and dayTimeDuration Types
- XPath Functions Namespace, Function Names, Predeclared Namespaces, The default function namespace declaration
- xqdoc tags, Using Comments for Documentation
- XQJ (XQuery API for Java), XQuery API for Java (XQJ)
- XQuery, What Is XQuery?, Uses for XQuery, The Design of the XQuery Language, XQuery in Context, XQuery in Context, The Version Declaration, Conformance, Conformance, XML Version Support, XML Version Support, Option Declarations and Extension Expressions, Extension Expressions, Specifying Serialization Parameters, Relational Versus XML Data Models, XQuery and XPath
- common uses, Uses for XQuery
- features set, What Is XQuery?
- implementation-specific features, Conformance, Conformance, XML Version Support, XML Version Support, Option Declarations and Extension Expressions, Extension Expressions, Specifying Serialization Parameters
- conformance, Conformance
- extension expressions, Extension Expressions
- option declarations, Option Declarations and Extension Expressions
- serialization parameters, specifying, Specifying Serialization Parameters
- setting query context, XML Version Support
- XML version support, XML Version Support
- SQL vs., Relational Versus XML Data Models
- version declaration, The Version Declaration
- web site, The Design of the XQuery Language
- XPath and, XQuery in Context, XQuery and XPath
- XSLT vs., XQuery in Context
- XQuery 1.0 and XPath 2.0 Full-Text recommendation, Full-Text Search
- XQuery API for Java (XQJ), XQuery API for Java (XQJ)
- XQueryX, XQueryX
- xs namespace, Namespace Declarations in Queries
- xs: prefix (types), Types, Namespaces and XQuery
- xs:anyAtomicType, The Built-in Types, xs:anyAtomicType
- xs:anyType, Assigning Type Annotations to Nodes, xs:anyType
- xs:anyURI, Working with URIs, xs:anyURI
- xs:base64Binary, xs:base64Binary
- xs:boolean, xs:boolean
- xs:byte, xs:byte
- xs:date, The Built-in Types, The Date and Time Types, Adjusting time zones, Finding the time zone of a value, Finding the time zone of a value, Extracting Components of Dates, Times, and Durations, Using Arithmetic Operators on Dates, Times, and Durations, xs:date
- comparisons, Finding the time zone of a value
- component extraction, Extracting Components of Dates, Times, and Durations
- date formats, Adjusting time zones
- finding time zone of a value, Finding the time zone of a value
- subtracting values, Using Arithmetic Operators on Dates, Times, and Durations
- xs:dateTime, The Date and Time Types, Finding the time zone of a value, Finding the time zone of a value, Using Arithmetic Operators on Dates, Times, and Durations, Using Arithmetic Operators on Dates, Times, and Durations, xs:date
- comparisons, Finding the time zone of a value
- extracting entire date or time from, Using Arithmetic Operators on Dates, Times, and Durations
- finding time zone of a value, Finding the time zone of a value
- subtracting values, Using Arithmetic Operators on Dates, Times, and Durations
- xs:dayTimeDuration, Explicit versus implicit time zones, Finding the time zone of a value, The yearMonthDuration and dayTimeDuration Types, xs:dayTimeDuration
- implicit time zone as, Explicit versus implicit time zones
- time zone expressed as, Finding the time zone of a value
- xs:decimal, The Numeric Types, xs:decimal
- xs:double, xs:decimal
- xs:duration, The Duration Types, Extracting Components of Dates, Times, and Durations, xs:duration
- component extraction, Extracting Components of Dates, Times, and Durations
- xs:ENTITIES, xs:ENTITIES
- xs:ENTITY, xs:ENTITIES
- xs:float, xs:float
- xs:gDay, The Date Component Types, xs:gDay
- xs:gMonth, The Date Component Types, xs:gMonth
- xs:gMonthDay, The Date Component Types, xs:gMonthDay
- xs:gYear, The Date Component Types, xs:gYear
- xs:gYearMonth, The Date Component Types, xs:gYearMonth
- xs:hexBinary, xs:hexBinary
- xs:ID, Working with IDs, xs:ID
- xs:IDREF, Working with IDs, xs:IDREF
- xs:IDREFS, Working with IDs, xs:IDREFS
- xs:int, xs:int
- xs:integer, Atomic Type Names As Sequence Types, The Numeric Types, xs:int
- xs:language, xs:language
- xs:long type, xs:long
- xs:Name, xs:Name
- xs:NCName, xs:Name
- xs:negativeInteger, xs:negativeInteger
- xs:NMTOKEN, xs:NMTOKEN
- xs:NMTOKENS, xs:NMTOKENS
- xs:nonNegativeInteger, xs:nonNegativeInteger
- xs:nonPositiveInteger, xs:nonPositiveInteger
- xs:normalizedString, xs:normalizedString
- xs:NOTATION, xs:NOTATION
- xs:positiveInteger, xs:positiveInteger
- xs:QName, Working with Qualified Names, Constructing Qualified Names, xs:QName
- constructor, Constructing Qualified Names
- xs:short, xs:short
- xs:string, Casting among the primitive types, Casting among the primitive types, The xs:string Type, The xs:string Constructor and the string Function, Working with URIs, xs:string
- casting atomic value of any type to, Casting among the primitive types
- casting to any other primitive type, Casting among the primitive types
- constructor, The xs:string Constructor and the string Function
- URI arguments for functions, Working with URIs
- xs:time, The Date and Time Types, Finding the time zone of a value, Finding the time zone of a value, Extracting Components of Dates, Times, and Durations, Using Arithmetic Operators on Dates, Times, and Durations, xs:time
- comparisons, Finding the time zone of a value
- component extraction, Extracting Components of Dates, Times, and Durations
- finding time zone of a value, Finding the time zone of a value
- subtracting values, Using Arithmetic Operators on Dates, Times, and Durations
- xs:token, xs:token
- xs:unsignedByte, xs:unsignedByte
- xs:unsignedInt, Atomic Type Names As Sequence Types, xs:unsignedInt
- xs:unsignedLong, xs:unsignedShort
- xs:unsignedShort, xs:unsignedShort
- xs:untyped, Assigning Type Annotations to Nodes, xs:untyped
- xs:untypedAtomic, Atomic Values and Types, Casting among the primitive types, Casting among the primitive types, Assigning Type Annotations to Nodes, xs:untypedAtomic
- casting atomic values of any type to, Casting among the primitive types
- casting to any other primitive type, Casting among the primitive types
- xs:yearMonthDuration, The yearMonthDuration and dayTimeDuration Types, xs:yearMonthDuration
- xsi namespace, Namespace Declarations in Queries
- xsi:nil attribute, Empty and nil values, Relational Versus XML Data Models
- xsi:type, Constructing Qualified Names
- XSLT, XQuery in Context, XQuery and XPath, Paradigm differences: push versus pull, Optimization for particular use cases, Convenient features of XSLT
- XQuery vs., XQuery in Context, XQuery and XPath, Paradigm differences: push versus pull, Optimization for particular use cases, Convenient features of XSLT
- convenient features of XSLT 2.0 lacking in XQuery, Convenient features of XSLT
- optimization for particular use cases, differences in, Optimization for particular use cases
- paradigm differences, push and pull stylesheets, Paradigm differences: push versus pull
- XSLT 2.0 and XQuery 1.0 Serialization, Serialization
Y
- years, Extracting Components of Dates, Times, and Durations, xs:gYear
- extracting from dates, times, and durations, Extracting Components of Dates, Times, and Durations
- xs:gYear type, xs:gYear
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.