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 (&gt:), 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

J

Java, XQuery API (XQJ), XQuery API for Java (XQJ)

joins, Joins, Outer Joins, Working with Multiple Tables and Subqueries

outer, Outer Joins
SQL vs. XQuery, Working with Multiple Tables and Subqueries

K

keywords, Categories of Expressions, Keywords and Names, Keywords and Names, External Variables

external, External Variables
for categories of expressions, Categories of Expressions
whitespace separators, Keywords and Names

kind tests in path expressions, Node kind tests, Sequence Types and Schemas

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

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.

Table of Contents for Index

Create new playlist

Sign In

Sign Up

Index

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X

Y

Table of Contents for
Index