Index
Symbols
- ! (see simple map operator)
- != (see general comparisons)
- " (see quote ("))
- # (see pound sign (#))
- $ (see dollar sign ($))
- % (see percent sign (%))
- & (see ampersand (&))
- ' (see apostrophe ('))
- ( ) (see parentheses ( ( ) ))
- * (see asterisk (*))
- + (see plus sign (+))
- , (see comma (,))
- - (see hyphen (-)) (see minus sign (-))
- . (see period (.))
- / (see slash (/))
- // (see double slash (//))
- : (see colon (:))
- ; (see semicolon (;))
- < (see less than symbol (<))
- <!-- and -->, (XML comment delimiters), Comments, XML Comments
- <? and ?> (processing instruction delimiter), Processing Instructions, Constructing Processing Instructions
- = (see equals sign (=))
- => (see arrow operator (=>))
- > (see greater than symbol (>))
- ? (see question mark (?))
- @ (see at sign (@))
- [ ] (see square brackets ( [ ] ))
- (see backslash ())
- ^ (see caret (^))
- ``[ and ]`` (string constructors), String Constructors
- { } (see curly braces ( { } ))
- | (see vertical bar (|))
- || (string concatenation operator), Concatenating Strings
- ‰ (see per-mille character (‰))
A
- abs function, Functions on Numbers, Built-in Function Reference
- absolute URIs, Working with URIs
- absolute value, Built-in Function Reference
- acos function, Built-in Function Reference
- adaptive method (serialization), Serialization Methods
- add-attributes (useful function), Adding Attributes to an Element
- addition, Arithmetic Operations, Addition, Subtraction, and Multiplication
- adjust-date-to-timezone function, Adjusting time zones, Built-in Function Reference
- adjust-dateTime-to-timezone function, Adjusting time zones, Built-in Function Reference
- adjust-time-to-timezone function, Adjusting time zones, Built-in Function Reference
- aggregate functions, Sequences, Aggregating Values
- aggregating values, Aggregating and Grouping Values, Aggregating Values
- allow-duplicate-names (serialization), Serialization Parameters
- allowing empty (keywords), Outer joins with allowing empty
- Altova, Processing Scenarios
- ampersand (&)
- analysis phase (see static analysis phase)
- analyze-string function, Splitting Strings Apart, Built-in Function Reference
- ancestor-or-self:: axis, Axes
- ancestor:: axis, Axes
- ancestors, The node family
- anchors (in regular expressions), Anchors
- and (operator), Logical (and/or) Expressions
- annotations, Annotations
- anonymous function, Inline Function Expressions
- apostrophe (')
- append function, Built-in Function Reference
- apply function, Built-in Function Reference
- arc cosine, math:acos function, Built-in Function Reference
- arc sine, math:asin function, Built-in Function Reference
- arc tangent
- arguments (functions)
- arithmetic operations, Arithmetic Operations
- differences from XPath 1.0, Arithmetic and Comparison Expressions
- division, Division
- modulus (remainder), Modulus (Remainder)
- numeric type promotion in expressions, Numeric Type Promotion
- on dates, times, and durations, Using Arithmetic Operators on Dates, Times, and Durations
- on multiple values, Arithmetic Operations on Multiple Values
- on NaN, Arithmetic Operations
- precedence, Precedence of Arithmetic Operators
- types and, Arithmetic Operations and Types
- whitespace, Addition, Subtraction, and Multiplication
- arity, Function Signatures, The Function Name
- array() test, Arrays and Sequence Types
- array: namespace prefix, Built-in Function Reference
- array:append function, Changing Arrays, Built-in Function Reference
- array:filter function, Changing Arrays, Built-in Function Reference
- array:flatten function, Changing Arrays, Built-in Function Reference
- array:fold-left function, Built-in Function Reference
- array:fold-right function, Built-in Function Reference
- array:for-each function, Built-in Function Reference
- array:for-each-pair function, Built-in Function Reference
- array:get function, Using the array:get function, Built-in Function Reference
- array:head function, Querying Arrays, Built-in Function Reference
- array:insert-before function, Changing Arrays, Built-in Function Reference
- array:join function, Changing Arrays, Built-in Function Reference
- array:put function, Changing Arrays, Built-in Function Reference
- array:remove function, Changing Arrays, Built-in Function Reference
- array:reverse function, Changing Arrays, Built-in Function Reference
- array:size function, Querying Arrays, Built-in Function Reference
- array:sort function, Changing Arrays, Built-in Function Reference
- array:subarray function, Changing Arrays, Built-in Function Reference
- array:tail function, Querying Arrays, Built-in Function Reference
- arrays, Arrays-Arrays and Sequence Types
- atomization, Arrays and Atomization
- built-in functions
- changing, Changing Arrays
- comparing, Querying Arrays
- constructors, Constructing Arrays
- definition, Arrays
- filtering, Changing Arrays, Built-in Function Reference
- flattening, Changing Arrays, Built-in Function Reference
- folding, Built-in Function Reference, Built-in Function Reference
- head, Querying Arrays
- in data model, The XQuery Data Model
- invoking as functions, Invoking arrays as functions
- iterating over with function, Built-in Function Reference, Built-in Function Reference
- joining (merging), Changing Arrays, Built-in Function Reference
- looking up values, Looking Up Array Values
- querying, Querying Arrays
- returning subarray, Changing Arrays, Built-in Function Reference
- reversing the order of, Changing Arrays, Built-in Function Reference
- sequence type, Arrays and Sequence Types
- sequences vs., Arrays Versus Sequences
- size, Querying Arrays
- sorting, Changing Arrays, Built-in Function Reference
- tail, Querying Arrays
- arrow operator (=>), Calling Functions with the Arrow Operator
- as (keyword), Type Declarations
- ascending order, Order modifiers
- asin function, Built-in Function Reference
- assertions, type, The Treat Expression
- asterisk (*)
- at (keyword)
- at sign (@)
- atan function, Built-in Function Reference
- atan2 function, Built-in Function Reference
- atomic types
- atomic values, Atomic Values
- atomization, Atomic Values, Atomization
- atoms (regular expressions), Atoms
- attribute value normalization, Boundary whitespace
- attribute() test, Element and Attribute Tests
- attribute:: axis, Axes
- attributes
- available-environment-variables function, Built-in Function Reference
- averages
- avg function, Sequences, Aggregating Values, Functions on Numbers, Built-in Function Reference
- avg-empty-is-zero (useful function), Counting “Missing” Values
- axes, Axes
- axis steps, Steps
B
- back-references, Back-References
- backslash ()
- base URIs, Base and Relative URIs
- BaseX, Processing Scenarios, RESTXQ
- BETWEEN condition (SQL), Comparisons
- between-inclusive (useful function), Value Comparisons
- binary data
- binding sequence, The for Clause
- block escapes in regular expressions, Block Escapes
- body, query, The Query, Structure of a Query: Prolog and Body
- boolean attributes (HTML), Serialization Methods
- Boolean values
- boundary whitespace (in direct element constructors), Boundary whitespace
- boundary-space declaration, The boundary-space declaration
- braces (see curly braces ( { } ))
- branches (in regular expressions), Parenthesized Sub-Expressions and Branches
- built-in functions
- built-in schemas, added by implementations, Setting the Query Context
- built-in types (see types)
- byte-order-mark (serialization), Serialization Parameters
C
- c, C (name character) in regular expressions, Multi-Character Escapes
- calendar, in formatting dates/times, Built-in Function Reference
- canonical representation, types, Atomic Types
- caret (^)
- carriage return (
), in regular expressions, Representing Individual Characters
- case clause
- case-sensitivity
- casting, Types, Constructors and Casting-Casting among derived types
- cast expression, The Cast Expression, The Treat Expression
- castable expression, The Castable Expression
- date/time types, Comparing Dates and Times
- from any type to xs:string or xs:untypedAtomic, Casting to xs:string or xs:untypedAtomic
- rules, Casting Rules
- to any type from xs:string or xs:untypedAtomic, Casting from xs:string or xs:untypedAtomic
- untyped values, Casting of Untyped Values
- whitespace, Casting from xs:string or xs:untypedAtomic
- xs:anyURI values, Casting and Comparing xs:anyURI Values
- xs:boolean values, Casting xs:boolean Values
- xs:decimal values, Casting xs:decimal Values
- xs:double values, Casting xs:double Values
- xs:float values, Casting xs:float Values
- xs:integer values, xs:integer
- catalog.xml document (example), Easing into XQuery
- catch clause, Try/Catch Expressions
- category escapes in regular expressions, Category Escapes
- <![CDATA[ and ]]> CDATA section delimiters, CDATA Sections
- CDATA sections, CDATA Sections
- ceiling function, Functions on Numbers, Built-in Function Reference
- change-element-names-deep (useful function), Changing Names
- character class expressions, Character Class Expressions
- character maps, Serialization Parameters
- character references, XML Entity and Character References
- child:: axis, Axes
- children, The node family
- closure, Inline Function Expressions
- codepoint-equal function, Comparing Strings, Built-in Function Reference
- codepoints-to-string function, Converting Between Codepoints and Strings, Built-in Function Reference
- collations, Collations-Specifying a collation
- argument to built-in functions, Specifying a collation
- collation-key function, Built-in Function Reference
- default collation declaration, Specifying a collation
- in group by clause, Grouping Using the group by Clause, Specifying a collation
- in order by clause, Order modifiers, Specifying a collation
- supported by implementations, Supported collations, Setting the Query Context
- URIs, Collations, Specifying a collation
- collections, Accessing a Collection
- colon (:)
- comma (,)
- concatenating sequences with sequence constructor, Sequences, Sequence Constructors
- grouping separator when formatting numbers, The Decimal Format Declaration
- interaction with parentheses and curly braces, Precedence and Parentheses
- separating array members, Constructing Arrays
- separating expressions, The Query, Precedence and Parentheses
- separating function arguments, Function Calls, Calling Functions
- separating map entries, Using a map constructor
- separator character in URIs, Escaping URIs
- comments
- comparisons, Comparison Expressions-Node Comparisons
- compare function, Comparing Strings, Built-in Function Reference
- date component types, The Date Component Types
- dates and times, Comparing Dates and Times
- deep-equal function, Selecting Distinct Values
- default collation, using, Collations
- durations, Comparing Durations
- general comparisons, General Comparisons
- in predicates, Comparisons in Predicates
- joins and types, Joins and Types
- node comparisons, Node Comparisons
- numeric values, Comparing Numeric Values
- relative position in document order, Document Order Comparisons
- strings, Comparing Strings, Comparing Entire Strings
- untyped values, Do You Need to Care About Types?
- value comparisons, Value Comparisons
- complex types, Simple and complex types
- component specifier (picture string), Built-in Function Reference
- computed constructors, Adding Attributes, Computed Constructors-Use Case: Turning Content to Markup
- concatenation
- conditional expressions, Conditional (if-then-else) Expressions
- conformance, Conformance
- constants, Variable Declarations
- construction declaration, Types and Newly Constructed Elements and Attributes
- constructors, Adding Elements and Attributes to Results-Use Case: Turning Content to Markup, Adding Elements and Attributes to Results
- (see also computed constructors)
- arrays, Constructing Arrays
- attribute, Adding XML Elements and Attributes
- computed, Computed Constructors
- direct, Adding Attributes, Direct Element Constructors
- document node, Constructing Document Nodes
- element, Adding XML Elements and Attributes, Direct Element Constructors
- maps, Constructing Maps
- processing instruction, Constructing Processing Instructions
- text node, Constructing Text Nodes
- type (see type constructors)
- types and, Types and Newly Constructed Elements and Attributes
- XML comment, Constructing Comments
- contains function, Comparing Strings, Determining Whether a String Contains Another String, Built-in Function Reference
- contains-token function, Comparing Strings, Determining Whether a String Contains Another String, Built-in Function Reference
- contains-word (useful function), Determining Whether a String Contains Another String
- content type (HTML serialization), Serialization Parameters
- content types for complex types, Simple and complex types
- context, The Context, A Closer Look at Context
- conversions (see type conversions)
- Coordinated Universal Time (see UTC (Coordinated Universal Time))
- copy-namespaces declaration, Controlling the Copying of Namespace Declarations
- cos function (cosine), Built-in Function Reference
- count clause (FLWORs), Using the count Clause
- count function, Sequences, Aggregating Values, Built-in Function Reference
- counters, Working with Positions and Sequence Numbers
- curly braces ( { } )
- current date and/or time, Constructing and Casting Dates and Times
D
- d, D in regular expressions, Multi-Character Escapes
- data function, Adding Elements, String and typed values of nodes, Nodes and Types, Built-in Function Reference
- data model, The XQuery Data Model
- arrays, Arrays
- atomic values, Atomic Values
- components, The XQuery Data Model
- diagram, The XQuery Data Model
- differences from XPath 1.0, Data Model
- document nodes, Document Nodes and the Data Model
- function items, Constructing Functions and Calling Them Dynamically
- maps, Invoking maps as functions
- nodes, Nodes
- processing instructions, Processing Instructions and the Data Model
- relational vs. XML, Relational Versus XML Data Models
- sequences, Sequences
- text nodes, Text Nodes and the Data Model
- XML comments, XML Comments and the Data Model
- data types (see types)
- databases
- dates and times, Working with Dates, Times, and Durations-The Date Component Types
- arithmetic operators, using on, Using Arithmetic Operators on Dates, Times, and Durations
- built-in functions, list of, Built-in Function Reference
- comparing, Comparing Dates and Times
- durations of time (see durations)
- extracting components, Extracting Components of Dates, Times, and Durations
- formats allowed, The Date and Time Types
- formatting, Formatting Dates and Times
- IETF, Built-in Function Reference
- including literal values in an expression, Literals
- subtracting durations from, Adding and Subtracting Durations from Dates and Times
- time zones, Time Zones
- types, The Date and Time Types
- dateTime function, Constructing and Casting Dates and Times, Built-in Function Reference
- days
- decimal formats
- decimal numbers, The xs:decimal Type
- decimal separator
- declarations, The Query, The Query
- deep-equal function, Node Comparisons, Selecting Distinct Values, Built-in Function Reference
- default clause (typeswitch expressions), The Typeswitch Expression
- default collation declaration, Specifying a collation
- default function namespace, Names affected by namespace declarations
- default namespace declarations
- default order (empty order declaration), Empty order
- default return (switch expressions), Switch Expressions
- default-collation function, Specifying a collation, Built-in Function Reference
- default-language function, Built-in Function Reference
- derived types, Atomic Types
- descendant-or-self:: axis, Axes
- descendant:: axis, Axes
- descendants, The node family
- descending order, Order modifiers
- digit
- direct constructors
- direct element constructors, Adding Attributes, Direct Element Constructors-Forcing boundary whitespace preservation
- adding attributes
- adding child elements, Enclosed expressions that evaluate to elements
- adding text content, Enclosed expressions that evaluate to atomic values
- containing enclosed expressions, Containing Enclosed Expressions
- containing literal characters, Containing Literal Characters
- containing other constructors, Containing Other Element Constructors
- escaping characters in, XML Entity and Character References
- modifying element from input document (example), Use Case: Modifying an Element from the Input Document
- namespace declarations, Declaring Namespaces in Direct Constructors, Namespace Declarations in Direct Element Constructors
- whitespace, Direct Element Constructors and Whitespace
- distinct-deep (useful function), Selecting Distinct Values
- distinct-values function, Selecting Distinct Values, Built-in Function Reference
- division
- doc function, Accessing a Single Document with a Function, Built-in Function Reference
- doc-available function, Accessing a Single Document with a Function, Built-in Function Reference
- doctype-public (serialization), Serialization Parameters
- doctype-system (serialization), Serialization Parameters
- document element, Roots, documents, and elements
- document order, Sorting in XQuery, Document Order
- document type declaration, Serialization Parameters
- document-node() test, Document Nodes and Sequence Types
- document-uri function, Finding the URI of a document, Built-in Function Reference
- documents, Documents
- dollar sign ($)
- dot-all mode, Representing Any Character, Using Flags
- double slash (//)
- DTDs, W3C XML Schema: A Brief Overview
- durations
- dynamic errors, Avoiding Dynamic Errors
- dynamic evaluation phase, The Query Processor, The Dynamic Evaluation Phase, What Is Static Typing?, Error Handling
- dynamic function calls
- dynamic paths, Dynamic Paths
E
- e
- effective boolean value, Effective Boolean Value
- boolean function and, Built-in Function Reference
- conditional expressions and, Conditional Expressions and Effective Boolean Value
- empty function and, Built-in Function Reference
- error conditions, Effective Boolean Value
- exists function and, Built-in Function Reference
- in predicates, Predicates
- in where clauses, The where Clause
- logical expressions and, Logical (and/or) Expressions
- not function and, Negating a Boolean Value, Built-in Function Reference
- of a zero-length string, Effective Boolean Value
- of NaN, Effective Boolean Value
- of the empty sequence, Effective Boolean Value
- on multiple atomic values, FORG0006
- quantified expressions and, Quantified Expressions
- element constructors (see computed constructors) (see direct element constructors)
- element() test, Element and Attribute Tests
- element-only content, Function Conversion Rules
- element-with-id function, Joining IDs and IDREFs, Built-in Function Reference
- elements
- adding to query results, Adding XML Elements and Attributes
- computed element constructors, Computed Element Constructors
- copying with modifications, Copying Input Elements with Modifications
- declarations in XML Schema, Element and Attribute Declarations
- direct element constructors, Direct Element Constructors
- finding with path expressions, Path Expressions
- in node hierarchy, The node family
- in-scope namespaces, In-Scope Versus Statically Known Namespaces
- names, Node identity and name
- namespaces, Namespaces
- nodes in data model, Node kinds
- string and typed values, String and typed values of nodes
- else keyword, Conditional (if-then-else) Expressions
- EMC Documentum xDB, Processing Scenarios
- empty content
- empty elements, Empty and nil values, Relational Versus XML Data Models
- empty function, Built-in Function Reference
- empty greatest/least
- empty order declaration, Empty order
- empty sequence, Sequences
- enclosed expressions, Direct Element Constructors
- encode-for-uri function, Escaping URIs, Built-in Function Reference
- encoding
- end condition (window clause), Windowing, Using start and end Conditions
- ends-with function, Comparing Strings, Determining Whether a String Contains Another String, Built-in Function Reference
- entity references, XML Entity and Character References
- entry (map), Maps
- entry function, Built-in Function Reference
- environment variables
- equals sign (=)
- comparing for equality (see general comparisons)
- separator character in URIs, Escaping URIs
- err: namespace prefix, Try/Catch Expressions
- err:additional, Try/Catch Expressions
- err:code, Try/Catch Expressions
- err:column-number, Try/Catch Expressions
- err:description, Try/Catch Expressions
- err:line-number, Try/Catch Expressions
- err:module, Try/Catch Expressions
- err:value, Try/Catch Expressions
- error function, The error and trace Functions, Built-in Function Reference
- errors
- escape-html-uri function, Escaping URIs, Built-in Function Reference
- escape-uri-attributes (serialization), Serialization Parameters
- escaped attribute (JSON conversion), Converting Between JSON and XML
- escaped-key attribute (JSON conversion), Converting Between JSON and XML
- escapes
- evaluation order, Precedence and Parentheses
- evaluation phase (see dynamic evaluation phase)
- every (keyword), Quantified Expressions
- exactly-one function, The zero-or-one, one-or-more, and exactly-one Functions, Built-in Function Reference
- except (operator), Sequences, The except Expression
- eXist, Processing Scenarios, RESTXQ
- exist function (SQL Server), Flexible Data Structures
- exists function, Built-in Function Reference
- exponent
- expressions, Expressions: XQuery Building Blocks
- extension expressions, Extension Expressions
- external context item, Setting the Context in the Prolog
- external functions, Declaring External Functions
- external variables, External Variables
F
- false function, Literals, Built-in Function Reference
- filter function, Built-In Higher-Order Functions, Built-in Function Reference
- find function, Built-in Function Reference
- flags (in regular expressions), Using Flags
- flatten function, Built-in Function Reference
- floating-point numbers, The xs:float and xs:double Types
- floor function, Functions on Numbers, Built-in Function Reference
- FLWORs, FLWORs, Selecting and Joining Using FLWORs-Joins and Types
- binding variables, Variables
- clauses, listed, FLWOR Expressions
- count clause, Using the count Clause
- embedded in another FLWOR, Subselects
- for clause, The for Clause
- group by clause, Grouping Using the group by Clause
- grouping results into categories, Grouping
- joining data from multiple sources, Joins
- let clause, The let Clause
- order by clause, The order by Clause
- path expressions vs., Selecting with Path Expressions
- return clause, The return Clause
- scope of variables, The Scope of Variables
- selecting distinct values, Selecting Distinct Values
- syntax diagram, FLWOR Expressions
- testing for the last item, Testing for the Last Item
- type declarations, Type Declarations in FLWORs
- variables
- where clause, The where Clause
- window clause, Windowing
- fn: namespace prefix, Predeclared Namespaces, Built-in Function Reference
- fn:analyze-string-result element, Built-in Function Reference
- fn:group element (in analyze-string results), Built-in Function Reference
- fn:match element (in analyze-string results), Splitting Strings Apart, Built-in Function Reference
- fn:non-match element (in analyze-string results), Splitting Strings Apart, Built-in Function Reference
- FOAP errors, FOAP0001
- FOAR errors, Division, Modulus (Remainder), xs:decimal, xs:double, xs:float, xs:integer, FOAR0001
- FOAY errors, Looking Up Array Values, FOAY0001
- FOCA errors, Casting xs:decimal Values, Casting xs:integer Values, FOCA0001-FOCA0006
- FOCH errors, FOCH0001-FOCH0004
- FODC errors, FODC0001-FODC0010
- FODF errors, FODF1280
- FODT errors, FODT0001
- FOER errors, FOER0000
- FOFD errors, FOFD1340
- FOJS errors, FOJS0001-FOJS0007
- fold-left function, Built-In Higher-Order Functions, Built-in Function Reference
- fold-right function, Built-In Higher-Order Functions, Built-in Function Reference
- following-sibling:: axis, Axes
- following:: axis, Axes
- FONS errors, FONS0004
- FOQM errors, FOQM0001-FOQM0006
- for clause (FLWORs), FLWORs, FLWOR Expressions, The for Clause
- for-each function, Built-In Higher-Order Functions, Built-in Function Reference
- for-each-pair function, Built-In Higher-Order Functions, Built-in Function Reference
- FORG errors, The position and last functions, Counting “Missing” Values, Do You Need to Care About Types?, Effective Boolean Value, Constructors, The zero-or-one, one-or-more, and exactly-one Functions, FORG0001-FORG0010
- format-date function, Formatting Dates and Times
- format-dateTime function, Formatting Dates and Times
- format-integer function, Formatting Integers
- format-number function, Formatting Decimal Numbers
- format-time function, Formatting Dates and Times
- formatting
- forward steps, Steps
- FORX errors, FORX0001-FORX0004
- FOTY errors, FOTY0012
- FOUT errors, FOUT1170
- FOXT errors, FOXT0001-FOXT0006
- fragment identifiers in URI references, Working with URIs
- ftand operator (full text), Full-Text Search
- ftnot operator (full text), Full-Text Search
- ftor operator (full text), Full-Text Search
- full-text searches, Full-Text Search-Full-Text Search
- function conversion rules, Sequence Types, Function Conversion Rules
- function items, Constructing Functions and Calling Them Dynamically
- function() test, Functions and Sequence Types
- function-arity function, Built-in Function Reference
- function-lookup function, Using function-lookup to Obtain a Function, Built-in Function Reference
- function-name function, Built-in Function Reference
- functions, Functions, Functions-Recursive Functions
- annotations, Annotations
- anonymous (inline), Inline Function Expressions
- arguments, Calling Functions
- arity, Function Signatures
- body, Function Declarations
- built-in
- calling, Function Calls, Calling Functions-Calling Functions with the Arrow Operator
- declarations, Function Declarations
- external, Declaring External Functions
- invalid use of context, Functions and Context
- named function references, Named Function References
- names
- parameters, The Parameter List
- recursive, Recursive Functions, Recursive Functions
- return type, Function Signatures
- signatures, Function Signatures
- treating arrays as, Invoking arrays as functions
- treating maps as, Invoking maps as functions
- FunctX, Useful Functions, Value Comparisons, User-Defined Functions
- add-attributes function, Adding Attributes to an Element
- avg-empty-is-zero function, Counting “Missing” Values
- between-inclusive function, Value Comparisons
- change-element-names-deep function, Changing Names
- contains-word function, Determining Whether a String Contains Another String
- distinct-deep function, Selecting Distinct Values
- id-from-element function, Joining IDs and IDREFs
- if-absent function, Absent values
- if-empty function, Default “missing” values
- max-string function, Aggregating Values
- min-non-empty-string function, Ignoring “Missing” Values
- open-ref-document function, Opening a document from a dynamic value
- pad-string-to-length function, Finding the Length of a String
- remove-attributes function, Removing Attributes from an Element
- remove-attributes-deep function, Removing Attributes from All Descendants
- remove-elements-deep function, Removing Child Elements
- remove-elements-not-contents function, Removing Child Elements
- replace-first function, Replacing Substrings That Match a Pattern
- substring-after-last function, Substrings
G
- ge operator (see value comparisons)
- general comparisons, General Comparisons
- generate-id function, Node identity and name, Generating Unique ID Values, Built-in Function Reference
- get function
- global attributes, Namespaces and Attributes
- global variables, Variable Declarations
- greater than symbol (>)
- group by clause (FLWORs), Grouping Using the group by Clause
- grouping, Aggregating and Grouping Values, Grouping-Constraining and Sorting on Aggregated Values, Grouping
- (see also group by clause (FLWORs))
- grouping separator
- grouping variable, Grouping Using the group by Clause
- gt operator (see value comparisons)
I
- i option ($flags argument), Using Flags
- i, I (initial) in regular expressions, Multi-Character Escapes
- IBM DB2, Processing Scenarios
- identity (nodes), Node identity and name
- idiv (integer division) operator, Arithmetic Operations, Division
- IDREFs, Working with IDs
- IDs, Working with IDs-Generating Unique ID Values
- element-with-id function, Built-in Function Reference
- example in input document, Working with IDs
- generate-id function, Built-in Function Reference
- id function, Joining IDs and IDREFs, Built-in Function Reference
- id-from-element (useful function), Joining IDs and IDREFs
- joining IDs and IDREFs, Joining IDs and IDREFs, Built-in Function Reference, Built-in Function Reference
- xs:ID type, xs:ID
- IETF dates, parsing, Built-in Function Reference
- if-absent (useful function), Absent values
- if-empty (useful function), Default “missing” values
- if-then-else expressions, Conditional (if-then-else) Expressions
- implementation-specific aspects, Implementation-Specific Features
- implicit time zones
- imports
- in (keyword in quantified expressions), Quantified Expressions
- IN condition (SQL), Comparisons
- in-scope namespaces, In-Scope Versus Statically Known Namespaces
- in-scope schema definitions, In-Scope Schema Definitions
- in-scope-prefixes function, Other Name-Related Functions, Data Model, Built-in Function Reference
- include-content-type (serialization), Serialization Parameters
- indenting
- index-of function, Sequences, Built-in Function Reference
- infinity
- inherit (copy-namespaces setting), Controlling the Copying of Namespace Declarations
- initial (i) escape in regular expressions, Multi-Character Escapes
- initializing expressions, Initializing Expressions
- inline function expressions, Inline Function Expressions
- innermost function, Built-in Function Reference
- input documents, Input Documents
- accessing, Accessing a Single Document with a Function
- copying elements with modifications in query, Copying Input Elements with Modifications
- finding the URI of, Finding the URI of a document
- including elements and attributes in query results, Including Elements and Attributes from the Input Document
- JSON, Types of Input and Output Documents
- namespace declaration, Namespaces, Namespace declarations and input elements
- namespaces, Namespaces and XQuery
- passing as variables, Using Variables
- specifying outside of query, Setting the Context Outside the Query
- text, Types of Input and Output Documents
- types of, Types of Input and Output Documents
- URIs (Uniform Resource Identifiers), Resolving URIs of input documents
- variations in, designing queries for, Robustness
- XML, Types of Input and Output Documents
- input expression (casting), The Cast Expression
- insert-before function, Sequences, Built-in Function Reference
- instance of expressions, The instance of Expression
- integer division (idiv) operator, Arithmetic Operations
- integers, The xs:integer Type, The xs:integer Type
- formatting, Formatting Integers
- xs:byte type, xs:byte
- xs:int type, xs:int
- xs:integer type, xs:integer
- xs:long type, xs:long
- xs:negativeInteger type, xs:negativeInteger
- xs:nonNegativeInteger type, xs:nonNegativeInteger
- xs:nonPositiveInteger type, xs:nonPositiveInteger
- xs:positiveInteger type, xs:NOTATION
- xs:short type, xs:short
- xs:unsignedByte type, xs:unsignedByte
- xs:unsignedInt type, xs:unsignedInt
- xs:unsignedLong type, xs:unsignedLong
- xs:unsignedShort type, xs:unsignedShort
- intermediate XML documents, Using Intermediate XML Documents
- internationalization, Internationalization Considerations
- Internationalized Resource Identifiers (IRIs), Working with URIs
- intersect (operator), Sequences, The intersect Expression
- iri-to-uri function, Escaping URIs, Built-in Function Reference
- IRIs (Internationalized Resource Identifiers), Working with URIs
- is (operator), Node identity and name, Node Comparisons
- ISSDs (see in-scope schema definitions)
- item() test in sequence types, Generic Sequence Types
- item-separator (serialization), Serialization Parameters
- items
J
- Java, XQuery API (XQJ), XQuery API for Java (XQJ)
- join function, Built-in Function Reference
- joins, Joins
- JSON, JSON-Converting Between JSON and XML
- converting to/from XML, Converting Between JSON and XML, Built-in Function Reference, Built-in Function Reference
- escapes, Built-in Function Reference, Built-in Function Reference
- handling duplicates, Built-in Function Reference, Built-in Function Reference
- mapping to data model, JSON
- parsing as input, Types of Input and Output Documents, Parsing JSON, Built-in Function Reference
- relationship to maps and arrays, JSON
- serialization of query results to, Serialization Methods
- serializing as output, Serializing JSON
- json-doc function, Accessing a Single Document with a Function, Parsing JSON, Built-in Function Reference
- json-node-output-method (serialization), Serialization Parameters, Serializing JSON
- json-to-xml function, Converting Between JSON and XML, Built-in Function Reference
L
- lang function, Determining the Language of an Element, Built-in Function Reference
- language
- last function, The position and last functions, Built-in Function Reference
- lax validation mode, Validation Mode
- le operator (see value comparisons)
- leading zeros
- less than symbol (<)
- let clause (FLWORs), FLWORs, FLWOR Expressions, The let Clause
- lexical QName, Namespaces and XQuery
- lexical representation, types, Atomic Types
- library modules, Library Modules
- LIKE conditions (SQL), Comparisons
- line breaks
- list types, List Types, List types
- literals, Literals
- load-xquery-module function, Loading a Library Module Dynamically, Using XQuery and XSLT Together, Built-in Function Reference
- local-name function, Node identity and name, Retrieving Node Names, Built-in Function Reference
- local-name-from-QName function, Other Name-Related Functions, Built-in Function Reference
- local: namespace prefix, Predeclared Namespaces
- logarithm
- logical expressions, Logical (and/or) Expressions
- lookup operator
- lower-case function, Converting Between Uppercase and Lowercase, Built-in Function Reference
- lt operator (see value comparisons)
M
- m option ($flags argument), Anchors, Using Flags
- main module, Assembling Queries from Multiple Modules
- mandatory digit
- map constructors, Constructing Maps
- map() test, Maps and Sequence Types
- map: namespace prefix, Built-in Function Reference
- map:contains function, Querying Maps, Built-in Function Reference
- map:entry function, Using map:entry and map:merge to create maps, Built-in Function Reference
- map:find function, Querying Maps, Built-in Function Reference
- map:for-each function, Iterating over Entries in a Map, Built-in Function Reference
- map:get function, Using the map:get function, Built-in Function Reference
- map:keys function, Querying Maps, Built-in Function Reference
- map:merge function, Using map:entry and map:merge to create maps, Changing Maps, Built-in Function Reference
- map:put function, Changing Maps, Built-in Function Reference
- map:remove function, Changing Maps, Built-in Function Reference
- map:size function, Querying Maps, Built-in Function Reference
- maps, Maps-Maps and Sequence Types
- built-in functions
- changing, Changing Maps
- comparing, Querying Maps
- constructing
- definition, Maps
- entries
- finding contents, Querying Maps, Built-in Function Reference
- in data model, The XQuery Data Model
- invoking as functions, Invoking maps as functions
- iterating over with function, Iterating over Entries in a Map, Built-in Function Reference
- keys, Maps, Using a map constructor
- looking up values, Looking Up Map Values
- merging, Changing Maps, Built-in Function Reference
- querying, Querying Maps
- sequence type, Maps and Sequence Types
- size, Querying Maps, Built-in Function Reference
- testing contents, Querying Maps, Built-in Function Reference
- MarkLogic, Processing Scenarios, Dynamic Paths, RESTXQ
- matches function, Comparing Strings, Matching a String to a Pattern, Built-in Function Reference
- math: namespace prefix, Built-in Function Reference
- math:acos function, Functions on Numbers, Built-in Function Reference
- math:asin function, Functions on Numbers, Built-in Function Reference
- math:atan function, Functions on Numbers, Built-in Function Reference
- math:atan2 function, Functions on Numbers, Built-in Function Reference
- math:cos function, Functions on Numbers, Built-in Function Reference
- math:exp function, Functions on Numbers, Built-in Function Reference
- math:exp10 function, Functions on Numbers, Built-in Function Reference
- math:log function, Functions on Numbers, Built-in Function Reference
- math:log10 function, Functions on Numbers, Built-in Function Reference
- math:pi function, Functions on Numbers, Built-in Function Reference
- math:pow function, Functions on Numbers, Built-in Function Reference
- math:sin function, Functions on Numbers, Built-in Function Reference
- math:sqrt function, Functions on Numbers, Built-in Function Reference
- math:tan function, Functions on Numbers, Built-in Function Reference
- max function, Sequences, Aggregating Values, Functions on Numbers, Built-in Function Reference
- max-string (useful function), Aggregating Values
- media-type (serialization), Serialization Parameters
- member (array), Arrays
- merge function (maps), Built-in Function Reference
- meta element (HTML), serialization, Serialization Methods
- metacharacters, Representing Individual Characters
- method (serialization), Serialization Parameters
- Microsoft SQL Server, Processing Scenarios
- MIME type (serialization), Serialization Parameters
- min function, Sequences, Aggregating Values, Functions on Numbers, Built-in Function Reference
- min-non-empty-string (useful function), Ignoring “Missing” Values
- minus sign (-)
- minutes
- missing values, Relational Versus XML Data Models
- mixed content
- mod (modulus) operator, Arithmetic Operations, Modulus (Remainder)
- modularity of queries, Modularity
- module declaration, Library Modules
- module imports, Importing a Library Module
- modules, The Query, Assembling Queries from Multiple Modules-Loading a Library Module Dynamically
- months
- moving averages, Sliding Windows
- multi-character escapes in regular expressions, Multi-Character Escapes
- multi-line mode, Anchors
- multiplication, Addition, Subtraction, and Multiplication
N
-
(line feed) in regular expressions, Representing Individual Characters
- name function, Node identity and name, Built-in Function Reference
- name tests, Node name tests
- named function references, Named Function References
- names
- affected by namespace declarations in XQuery, Names affected by namespace declarations
- best practices, Choosing Names
- built-in functions related to, list of, Built-in Function Reference
- computed element constructors, Names of computed element constructors
- element and attribute nodes, Node identity and name
- function names, The Function Name
- local-name function, Node identity and name, Retrieving Node Names
- name function, Node identity and name, Retrieving Node Names
- node-name function, Node identity and name, Retrieving Node Names
- qualified, in query, Namespaces and XQuery
- variable names, Variable Names
- namespace declarations
- attributes and, Namespaces and Attributes
- controlling in results, Controlling Namespace Declarations in Your Results
- default
- in direct element constructors, Declaring Namespaces in Direct Constructors, Namespace Declarations in Direct Element Constructors, In-Scope Versus Statically Known Namespaces
- in input documents, Namespaces
- in module declarations, Other prolog namespace declarations
- in module imports, Other prolog namespace declarations
- in prolog, Prolog Namespace Declarations
- in queries, Namespace Declarations in Queries
- in schema imports, Other prolog namespace declarations
- in XML documents, Declaring Namespaces
- overriding, Namespace Declarations and Scope
- namespace prefixes, Namespaces, Declaring Namespaces
- namespace-node() test, XQST0134
- namespace-uri function, Retrieving Node Names, Built-in Function Reference
- namespace-uri-for-prefix function, Other Name-Related Functions, Data Model, Built-in Function Reference
- namespace-uri-from-QName function, Other Name-Related Functions, Built-in Function Reference
- namespace:: axis, Data Model
- namespaces, Namespaces, Namespaces and XQuery-URI-Qualified Names
- built-in functions related to, list of, Built-in Function Reference
- constructors, Namespace Declarations in Computed Constructors
- declarations (see namespace declarations)
- for array functions, Arrays
- for map functions, Maps
- function names, Function Names
- in schemas, Namespaces and XML Schema
- in XML documents, XML Namespaces-Namespace Declarations and Scope
- module imports, Importing a Library Module
- names in XQuery, Keywords and Names
- node name tests and, Node name tests and namespaces
- nodes in data model (deprecated), Node kinds
- predeclared, Predeclared Namespaces
- purpose, XML Namespaces
- qualified names, Namespaces
- reserved, XQST0045
- URIs, Namespace URIs
- user-defined function names, The Function Name
- version 1.0 vs. 1.1, Version Support
- Namespaces in XML (W3C recommendation), XML Namespaces
- NaN (not-a-number), The xs:float and xs:double Types
- native XML database, Uses for XQuery
- NCName, Working with IDs, xs:NCName
- ne operator (see value comparisons)
- negation operator (-), Arithmetic Operations
- new features
- next (window clause), Windowing, Windows Based on Previous or Next Items
- nilled elements, Empty and nil values, Relational Versus XML Data Models
- nilled function, Built-in Function Reference
- NMTOKEN, xs:NMTOKEN
- no-inherit (copy-namespaces setting), Controlling the Copying of Namespace Declarations
- no-preserve (copy-namespaces setting), Controlling the Copying of Namespace Declarations
- node kind tests, Node kind tests
- node tests, Node Tests
- node() test
- node-name function, Node identity and name, Retrieving Node Names, Built-in Function Reference
- nodes, Nodes
- atomization, Atomization
- built-in functions related to, list of, Built-in Function Reference
- comment, XML Comments and the Data Model
- comparisons, Node Comparisons
- document, Documents
- document order, Document Order
- family relationships, The node family
- finding base URI, Finding the base URI of a node
- function arguments as, Accepting arguments that are nodes versus atomic values
- hierarchy, The node hierarchy
- identity, Node identity and name
- in data model, The XQuery Data Model
- names, Node identity and name
- processing instruction, Processing Instructions and the Data Model
- retrieving names, Retrieving Node Names
- string and typed values, String and typed values of nodes
- text, Text Nodes
- types and, Nodes and Types
- untyped, String and typed values of nodes
- non-capturing groups, Using Sub-Expressions with Replacement Variables
- non-colonized name (NCName), xs:NCName
- normalization-form (serialization), Serialization Parameters
- normalize-space function, Normalizing Whitespace, Built-in Function Reference
- normalize-unicode function, Unicode Normalization, Built-in Function Reference
- NoSQL database, Processing Scenarios
- not equal (see comparisons)
- not function, Negating a Boolean Value, Negating a Boolean Value, Built-in Function Reference
- not in operator (full text), Full-Text Search
- not operator (SQL), Boolean operators
- not-a-number (see NaN (not-a-number))
- notations, XML, xs:NOTATION
- null values, relational vs. XML, Relational Versus XML Data Models
- number function, Sorting and types, The number Function, Built-in Function Reference
- numbers, Working with Numbers-The Decimal Format Declaration
- numeric (keyword in function signatures), The xs:numeric Type
- numeric literals, Literals, Constructing Numeric Values
O
- occurrence indicators
- omit-xml-declaration (serialization), Serialization Parameters
- one-or-more function, The zero-or-one, one-or-more, and exactly-one Functions, Built-in Function Reference
- only end (window clause), Windows Based on Position
- open-ref-document (useful function), Opening a document from a dynamic value
- operand expressions, The Typeswitch Expression
- operators
- optimization
- option declarations, Specifying Serialization Parameters by Using Option Declarations, The Option Declaration
- optional digit
- optional features, Conformance
- or (operator), Logical (and/or) Expressions
- Oracle, Processing Scenarios
- order by clause (FLWORs), FLWORs, The order by Clause
- order.xml document (example), Easing into XQuery
- ordered (ordering mode setting), The ordering mode declaration
- ordered expressions, The unordered expression
- ordering mode declaration, The ordering mode declaration
- ordinal numbers
- outer joins, Outer Joins
- outermost element, Roots, documents, and elements
- outermost function, Built-in Function Reference
- output declaration
- output documents
- output methods (serialization), Serialization Methods, Serialization Parameters
- overflow, xs:decimal, xs:double, xs:float, xs:integer, FODT0001
- oXygen XML Editor, Processing Scenarios
P
- p, P
- pad-string-to-length (useful function), Finding the Length of a String
- parameters
- parent:: axis, Axes
- parentheses ( ( ) ), Precedence and Parentheses
- (see also empty sequence)
- (: :) (XQuery comment delimiters), Comments
- concatenating sequences with sequence constructor, Sequence Constructors
- enclosing test expression after if keyword, Conditional (if-then-else) Expressions
- escaping in regular expressions, Representing Individual Characters
- in function calls, Function Calls, Calling Functions
- in sequence constructors, Precedence and Parentheses
- interaction with commas and curly braces, Precedence and Parentheses
- precedence and, Precedence and Parentheses
- sub-expressions in regular expressions, Parenthesized Sub-Expressions and Branches, Back-References, Using Sub-Expressions with Replacement Variables
- using for query clarity, Improving the Layout
- parents, The node family
- parse-ietf-date function, Built-in Function Reference
- parse-json function, Parsing JSON, Built-in Function Reference
- parse-xml function, Built-in Function Reference
- parse-xml-fragment function, Built-in Function Reference
- partial function application, Partial Function Application
- passive character (format-number picture string), Built-in Function Reference
- path expressions, Path Expressions, Navigating XML by Using Paths-Dynamic Paths
- path function, Built-in Function Reference
- pattern separator
- per-mille character (‰)
- percent sign (%)
- performance, Performance
- period (.)
- pessimistic static typing, What Is Static Typing?
- pi (mathematical constant), retrieving using math:pi function, Built-in Function Reference
- picture string
- pipelining, Reducing Complexity
- place, in formatting dates/times, Built-in Function Reference
- placeholder, in partial function application, Partial Function Application
- plus sign (+)
- position (array), Arrays
- position function, The position and last functions, Adding Sequence Numbers to Results, Built-in Function Reference
- positional variable, Adding Sequence Numbers to Results
- positions, Working with Positions and Sequence Numbers
- postfix lookup, Using the lookup operator on maps
- pound sign (#)
- power, math:pow function, Built-in Function Reference
- pragmas, Extension Expressions
- precedence, Precedence and Parentheses
- preceding-sibling:: axis, Axes
- preceding:: axis, Axes
- predeclared namespaces
- predicates, Path Expressions, Predicates-More Complex Predicates
- prefix-from-QName function, Other Name-Related Functions, Built-in Function Reference
- prefixes (see namespace prefixes)
- presentation modifier (picture string), Built-in Function Reference
- preserve
- previous (window clause), Windowing, Windows Based on Previous or Next Items
- prices.xml document (example), Easing into XQuery
- primary expressions, Categories of Expressions
- primitive types, Atomic Types
- %private, Private Functions and Variables
- private functions, Private Functions and Variables
- private variables, Private Functions and Variables
- processing instructions, Processing Instructions
- processing model for XQuery, Processing Queries
- processing-instruction() test, Querying Processing Instructions
- prolog, The Query, Scope of namespace declarations, Structure of a Query: Prolog and Body
- proximity (full text), Full-Text Search
- %public, Private Functions and Variables
- pull stylesheets, Paradigm differences: push versus pull
- push stylesheets, Paradigm differences: push versus pull
- put function, Built-in Function Reference
Q
- q option ($flags argument), Using Flags
- QName function, Constructing Qualified Names, Built-in Function Reference
- QNames (see qualified names)
- qualified names, Namespaces, Working with Qualified Names-Other Name-Related Functions
- quantified expressions, Quantified Expressions
- quantifiers
- queries
- query processor, The Query Processor
- question mark (?)
- quote ("), Literals
- Q{ and }, delimiters of URI-qualified name, URI-Qualified Names
R
-
(carriage return) in regular expressions, Representing Individual Characters
- random-number-generator function, Constructing Numeric Values, Built-in Function Reference
- range expressions, Range expressions
- ranking, Using the count Clause
- RaptorXML, Processing Scenarios
- recursion, Why Define Your Own Functions?, Recursive Functions
- regular expressions, Regular Expressions-Using Sub-Expressions with Replacement Variables, Character Class Expressions
- (see also character class expressions)
- anchors, Anchors
- atoms, Atoms
- back-references, Back-References
- block escapes, Block Escapes
- branches, Parenthesized Sub-Expressions and Branches
- built-in functions
- category escapes, Category Escapes
- entity references, Representing Individual Characters
- flags, Using Flags
- matching string to a pattern, Matching a String to a Pattern
- multi-character escapes, Multi-Character Escapes
- non-capturing groups, Using Sub-Expressions with Replacement Variables
- normal characters, Representing Individual Characters
- parenthesized sub-expressions, Parenthesized Sub-Expressions and Branches
- period (.) wildcard, Representing Any Character
- quantifiers, Quantifiers
- reluctant quantifiers, Reluctant Quantifiers
- replacing substrings matching a pattern, Replacing Substrings That Match a Pattern
- single-character escapes, Representing Individual Characters
- structure, The Structure of a Regular Expression
- sub-expressions with replacement variables, Using Sub-Expressions with Replacement Variables
- tokenizing on, Splitting Strings Apart
- relational databases
- relative path expressions, Path Expressions and Context
- relative URIs, Working with URIs
- RELAX NG, W3C XML Schema: A Brief Overview
- relevance (full text), Full-Text Search
- reluctant quantifiers, Reluctant Quantifiers
- remainder after dividing (modulus), Arithmetic Operations
- remove function, Built-in Function Reference
- remove-attributes (useful function), Removing Attributes from an Element
- remove-attributes-deep (useful function), Removing Attributes from All Descendants
- remove-elements-deep (useful function), Removing Child Elements
- remove-elements-not-contents (useful function), Removing Child Elements
- replace function, Replacing Substrings That Match a Pattern, Built-in Function Reference
- replace-first (useful function), Replacing Substrings That Match a Pattern
- reserved words, Keywords and Names
- resolve-QName function, Constructing Qualified Names, Built-in Function Reference
- resolve-uri function, Resolving URIs, Built-in Function Reference
- RESTXQ, RESTXQ-XQuery API for Java (XQJ)
- results, The Results of the Query
- return clause (FLWORs), FLWORs, FLWOR Expressions, The return Clause
- reverse axes, positional predicates and, Positional predicates and reverse axes
- reverse function, Range expressions, Reversing the Order, Built-in Function Reference
- reverse steps, Steps
- robustness of queries, Robustness
- Roman numerals, formatting integers as, Built-in Function Reference
- root
- accessing from a particular context, Accessing the Root
- root element, Roots, documents, and elements
- root function, Accessing the Root, Documents, Built-in Function Reference
- root node, Roots, documents, and elements
- round function, Functions on Numbers, Built-in Function Reference
- round-half-to-even function, Functions on Numbers, Built-in Function Reference
S
- s option ($flags argument), Representing Any Character, Using Flags
- s, S (whitespace) in regular expressions, Splitting Strings Apart, Multi-Character Escapes
- satisfies (keyword), Quantified Expressions
- Saxon, Processing Scenarios, Dynamic Paths, Resolving URIs of input documents, Serialization Parameters, Documents and URIs, The Option Declaration, Built-in Function Reference
- schema import, Schema Imports
- schema-attribute() test, Sequence Types and Schemas
- schema-element() test, Sequence Types and Schemas
- schemas, Using Schemas with XQuery-Sequence Types and Schemas
- complex types, Simple and complex types
- defined, What Is a Schema?
- in-scope schema definitions (ISSDs), In-Scope Schema Definitions
- namespaces in, Namespaces and XML Schema
- node kind tests for elements and attributes, Node kind tests
- reasons to use with queries, Why Use Schemas with Queries?
- role in error checking, Why Use Schemas with Queries?
- role in optimization, Why Use Schemas with Queries?
- sequence types and, Sequence Types and Schemas
- simple types, Simple and complex types
- support for schema imports and validation, Conformance
- types, Types
- validation, Schema Validation and Type Assignment
- XML Schema, XQuery and XML Schema, W3C XML Schema: A Brief Overview
- Schematron, W3C XML Schema: A Brief Overview
- scope (full text), Full-Text Search
- score (full text), Full-Text Search
- searches, full text, Full-Text Search
- seconds
- self:: axis, Axes
- semicolon (;)
- SENR errors, Serialization Errors, SENR0001
- separator characters (URI), escaping, Escaping URIs
- SEPM errors, SEPM0004-SEPM0019
- sequence constructors, Sequences, Sequence Constructors
- sequence numbers, Working with Positions and Sequence Numbers
- sequence types, Sequence Types-The instance of Expression
- arrays, Arrays and Sequence Types
- atomic types, Simple Type Names as Sequence Types
- document nodes, Document Nodes and Sequence Types
- elements and attributes, Sequence Types and Schemas
- function items, Functions and Sequence Types
- generic, Generic Sequence Types
- in function parameter lists, Sequence Types, The Parameter List
- item(), Generic Sequence Types
- list types, Simple Type Names as Sequence Types
- maps, Maps and Sequence Types
- matching, Sequence Type Matching
- matching any atomic value, Generic Sequence Types
- node(), Generic Sequence Types
- processing instructions, Processing Instructions and Sequence Types
- schemas and, Sequence Types and Schemas
- syntax diagram, Sequence Types
- text nodes, Text Nodes and Sequence Types
- union types, Simple Type Names as Sequence Types
- XML comments, Comments and Sequence Types
- sequences, Sequences
- arguments and, Argument lists and sequences
- arrays vs., Arrays Versus Sequences
- built-in functions related to, list of, Built-in Function Reference
- combining, Combining Results
- concatenating, Sequence Constructors
- empty, Sequences
- except, The except Expression
- filtering, Built-In Higher-Order Functions, Built-in Function Reference
- folding, Built-In Higher-Order Functions, Built-in Function Reference, Built-in Function Reference
- in data model, The XQuery Data Model
- inserting into, Built-in Function Reference
- intersection, The intersect Expression
- iterating over with function, Built-In Higher-Order Functions, Built-in Function Reference, Built-in Function Reference
- multi-item, general comparisons on, General comparisons on multi-item sequences
- removing items, Built-in Function Reference
- returning subsequence, Built-in Function Reference
- singleton, Sequences
- size (count function), Built-in Function Reference
- sorting, Built-In Higher-Order Functions
- union, The union Expression
- variables bound to particular value, Variables
- SERE errors, Serializing JSON, SERE0003-SERE0023
- serialization, The Results of the Query, Serializing Output-Serializing to a String
- adaptive method, Serialization Methods
- character maps, Specifying Serialization Parameters by Using a Separate XML Document
- errors, Serialization Errors
- output methods, Serialization Methods
- parameters, Serialization Parameters
- to a string, Serializing to a String
- to HTML, Serialization Methods
- to JSON, Serialization Methods
- to text documents, Serialization Methods
- to XHTML, Serialization Methods
- to XML, Serialization Methods
- serialize function, Serializing to a String, Built-in Function Reference
- SESU errors, SESU0007
- set operators (SQL), Combining queries by using set operators
- siblings, The node family
- simple content in complex types, Simple and complex types
- simple map operator, The Simple Map Operator
- simple types, Simple and complex types
- sine, math:sin function, Built-in Function Reference
- single quote (see apostrophe ('))
- single-character escapes in regular expressions, Representing Individual Characters
- singleton sequence, Sequences
- size function
- slash (/)
- sliding window, Windowing, Sliding Windows
- some (keyword), Quantified Expressions
- sort function, The sort Function, Built-In Higher-Order Functions, Built-in Function Reference
- sorting, Sorting in XQuery-The ordering mode declaration
- spaces (see whitespace)
- SQL
- combining SQL and XQuery, Combining SQL and XQuery
- comparison of SQL to XQuery, Comparing SQL Syntax with XQuery Syntax
- arithmetic operations, Arithmetic operators
- boolean operators, Boolean operators
- built-in functions, Functions
- combining sequences, Combining queries by using set operators
- comparisons, Comparisons
- conditions and operators, Conditions and Operators
- distinct values, Selecting Distinct Values
- grouping, Grouping
- joins, Working with Multiple Tables and Subqueries
- simple query, A Simple Query
- sorting, A Simple Query
- relational vs. XML data models, Relational Versus XML Data Models
- XQuery vs., XQuery Versus SQL, XQuery for SQL Users
- SQL/XML, SQL/XML
- sqrt function, Built-in Function Reference
- square brackets ( [ ] )
- square root, finding with math:sqrt function, Built-in Function Reference
- stable ordering, Stable ordering
- standalone (serialization), Serialization Parameters
- start condition (window clause), Windowing, Using start and end Conditions
- starts-with function, Comparing Strings, Determining Whether a String Contains Another String, Built-in Function Reference
- static analysis phase, The Query Processor, The Static Analysis Phase, What Is Static Typing?, Error Handling
- static base URI, Resolving URIs of input documents, Static base URI, Built-in Function Reference
- static function calls, dynamic function calls vs., Named Function References
- static typing, Static Typing-The zero-or-one, one-or-more, and exactly-one Functions
- static-base-uri function, Static base URI, Built-in Function Reference
- statically known namespaces, In-Scope Versus Statically Known Namespaces
- stemming (full text), Full-Text Search
- steps, Path Expressions, Steps
- stopwords (full text), Full-Text Search
- strict validation mode, Validation Mode
- string concatenation operator (||), Concatenating Strings
- string constructors, String Constructors
- string function, String and typed values of nodes, Do You Need to Care About Types?, The xs:string Constructor and the string Function, Built-in Function Reference
- string literals, Literals
- string value (nodes), String and typed values of nodes
- string-join function, Concatenating Strings, Built-in Function Reference
- string-length function, Finding the Length of a String, Built-in Function Reference
- string-to-codepoints function, Converting Between Codepoints and Strings, Built-in Function Reference
- strings, Working with Strings-Determining the Language of an Element
- built-in functions related to, list of, Built-in Function Reference
- collations, Collations
- comparing, Comparing Strings
- concatenating and splitting, Concatenating and Splitting Strings
- constructing, Constructing Strings
- finding length, Finding the Length of a String
- whitespace, Whitespace and Strings
- xs:normalizedString type, xs:normalizedString
- xs:string type, The xs:string Type, xs:string
- xs:token type, xs:token
- strip
- stylesheets, XSLT, Paradigm differences: push versus pull
- sub-expressions
- subarray function, Built-in Function Reference
- subselects (SQL), Subselects
- subsequence function, The position and last functions, Built-in Function Reference
- substitution groups, Sequence Types and Schemas
- substring function, Substrings, Built-in Function Reference
- substring-after function, Substrings, Built-in Function Reference
- substring-after-last (useful function), Substrings
- substring-before function, Substrings, Built-in Function Reference
- subtraction, Arithmetic Operations, Addition, Subtraction, and Multiplication
- subtype substitution, Subtype Substitution, Numeric Type Promotion
- sum function, Sequences, Aggregating Values, Functions on Numbers, Built-in Function Reference
- suppress-indentation (serialization), Serialization Parameters
- switch expressions, Switch Expressions
- syntax diagrams, explanation, Reading the Syntax Diagrams
- syntax errors, The Static Analysis Phase
T
- (tab) in regular expressions, Representing Individual Characters
- tabs, escaping in regular expressions, Representing Individual Characters
- tail function, Built-in Function Reference
- tangent, math:tan function, Built-in Function Reference
- target namespace
- templates (XSLT)
- test expressions, Conditional (if-then-else) Expressions
- text documents
- text nodes, Node kinds, Text Nodes
- text() test, Querying Text Nodes
- then keyword, Conditional (if-then-else) Expressions
- thesaurus (full text), Full-Text Search
- time zones, Time Zones-Finding the time zone of a value
- adjusting, Adjusting time zones, Built-in Function Reference-Built-in Function Reference
- date and time comparisons, Comparing Dates and Times
- explicit vs. implicit, Explicit versus implicit time zones
- finding for date and time values, Finding the time zone of a value
- formatting, Built-in Function Reference
- implicit-timezone function, Explicit versus implicit time zones
- representing UTC, Time Zones
- timezone-from-date function, Finding the time zone of a value, Built-in Function Reference
- timezone-from-dateTime function, Finding the time zone of a value, Built-in Function Reference
- timezone-from-time function, Finding the time zone of a value, Built-in Function Reference
- times (see dates and times)
- to (keyword)
- tokenize function, Splitting Strings Apart, Built-in Function Reference
- trace function, The error and trace Functions, Built-in Function Reference
- transform function, Using XQuery and XSLT Together, Built-in Function Reference
- translate function, Replacing Individual Characters in Strings, Built-in Function Reference
- treat expressions, The Treat Expression
- trigonometric functions, Functions on Numbers
- true function, Literals, Built-in Function Reference
- try/catch expressions, Try/Catch Expressions
- tumbling window, Windowing
- type annotations, Nodes and Types
- type constructors, Constructors
- type conversions, Types, Automatic Type Conversions
- type declarations, Type Declarations
- type errors, Type Checking in XQuery, Obvious Static Type Errors
- atomic values as steps, Other Expressions as Steps
- casting, Constructors, The Castable Expression
- casting empty sequence, The Cast Expression
- casting multiple items, The Cast Expression
- comparing different types, Value Comparisons, Comparisons in Predicates, Sorting and types
- comparing multiple items, Value Comparisons, Comparisons in Predicates
- comparing unsupported types, General comparisons and types
- context is not a node, A Closer Look at Context
- function arguments, Argument lists and the empty sequence, Argument lists and sequences, Sequence Types, Function Conversion Rules
- grouping on multiple items, Grouping Using the group by Clause
- handling data variations, Handling Data Variations
- ordering on multiple items, The order by Clause
- type promotion, Type Promotion
- typed value, String and typed values of nodes
- types, Types, A Closer Look at Types-Casting among derived types
- built-in, The Built-in Types, W3C XML Schema: A Brief Overview
- checking in XQuery, Type Checking in XQuery
- date and time, The Date and Time Types
- error checking and, Advantages of a Strong Type System
- general comparisons and, General comparisons and types
- list types, List types
- names
- numeric, The Numeric Types
- of constructed nodes, Types and Newly Constructed Elements and Attributes
- optimization and, Advantages of a Strong Type System
- sorting and, Sorting and types
- strong type system, advantages and disadvantages, Advantages of a Strong Type System
- user-defined, Types
- value comparisons and, Value Comparisons
- typeswitch expressions, The Typeswitch Expression
U
- unary lookup, Using the lookup operator on maps
- undeclare-prefixes (serialization), Serialization Parameters
- undeclaring namespaces, Namespace Declarations and Scope
- underflow, xs:decimal, xs:double, xs:float, xs:integer, FODT0001
- Unicode
- Unicode Codepoint Collation, Supported collations, Specifying a collation, Built-in Function Reference
- Unicode Collation Algorithm, Supported collations
- Uniform Resource Identifiers (see URIs (Uniform Resource Identifiers))
- Uniform Resource Names (see URNs (Uniform Resource Names))
- union (operator), Sequences, The union Expression
- union types, Union Types
- unordered (ordering mode setting), The ordering mode declaration
- unordered expressions, The unordered expression
- unordered function, The unordered function, Built-in Function Reference
- unparsed-text function, Accessing a Single Document with a Function, Built-in Function Reference
- unparsed-text-available function, Accessing a Single Document with a Function, Built-in Function Reference
- unparsed-text-lines function, Built-in Function Reference
- untyped items, Do You Need to Care About Types?
- arithmetic operations, Arithmetic Operations and Types
- atomic values, Atomic Values, Atomic Values and Types, xs:untypedAtomic
- elements or attributes, Assigning Type Annotations to Nodes
- function conversion rules, Function Conversion Rules
- general comparisons and, General comparisons and types
- nodes, String and typed values of nodes, Types, Nodes and Types
- used when no schema is present, Why Use Schemas with Queries?
- value comparisons and, Value Comparisons
- xs:untyped, xs:untyped
- updates, XQuery Update Facility
- upper-case function, Converting Between Uppercase and Lowercase, Built-in Function Reference
- uri-collection function, Accessing a Collection, Built-in Function Reference
- URI-qualified name, URI-Qualified Names
- URIs (Uniform Resource Identifiers), Working with URIs-Static base URI
- base and relative, Base and Relative URIs
- built-in functions, list of, Built-in Function Reference
- documents and, Documents and URIs
- escaping, Escaping URIs
- finding base URI of a node, Finding the base URI of a node
- finding for a document, Finding the URI of a document
- namespace, Namespace URIs
- of collections, Accessing a Collection
- of input documents, Resolving URIs of input documents
- resolving URIs, Resolving URIs
- static base URI, Static base URI
- xs:anyURI type, xs:anyURI
- URLs (Uniform Resource Locators), Working with URIs
- URNs (Uniform Resource Names), Namespace URIs, Working with URIs
- use-character-maps (serialization), Serialization Parameters
- user-defined functions, User-Defined Functions-Recursive Functions
- user-defined types, Atomic Types, User-defined types
- UTC (Coordinated Universal Time)
V
- validate expressions, The Validate Expression, Constructing Document Nodes
- validation mode, Validation Mode
- value comparisons, Value Comparisons
- value space, Atomic Types
- variables, Variables
- added by implementations, Setting the Query Context
- annotations, Annotations
- binding to typeswitch expressions, The Typeswitch Expression
- declarations in prolog, Variable Declarations
- expressions that bind them, Variables
- external, External Variables
- FLWORs
- imported from modules, The Scope of Variables
- names, Variable Names
- scope, The Scope of Variables
- setting values with let clause in expressions, FLWORs
- versions
- vertical bar (|)
W
- w, W (word character) in regular expressions, Splitting Strings Apart, Multi-Character Escapes
- W3C XML Schema (see XML Schema)
- weeks, formatting, Built-in Function Reference
- weighting (full text), Full-Text Search
- when expression (window clause), Windowing, Windowing, Windows Based on Previous or Next Items
- where clause (FLWORs), FLWORs, FLWOR Expressions, The where Clause
- whitespace
- width modifier (picture string), Built-in Function Reference
- wildcards
- window clause (FLWORs), Windowing-Sliding Windows
- word character (w) in regular expressions, Multi-Character Escapes
X
- x option ($flags argument), Using Flags
- XDM, The XQuery Data Model
- XHTML, serialization of query results to, Serialization Methods
- XML
- CDATA sections, CDATA Sections
- converting to/from JSON, Converting Between JSON and XML
- data model, relational vs., Relational Versus XML Data Models
- documents, Documents
- input documents, Input Documents, Types of Input and Output Documents
- notations, xs:NOTATION
- parsing from a string, Built-in Function Reference
- processing instructions, Processing Instructions
- serialization of query results to, Serialization Methods
- text nodes, Text Nodes
- version support in XQuery implementations, Version Support
- XML declaration, omitting in serialized results, Serialization Parameters
- XML Schema, XQuery and XML Schema, W3C XML Schema: A Brief Overview
- XML Schema Namespace, Namespaces and XQuery
- xml-to-json function, Converting Between JSON and XML, Built-in Function Reference
- xml: namespace prefix, Predeclared Namespaces
- xml:base attribute, Using the xml:base attribute
- xml:id attribute, Working with IDs
- xml:lang attribute, Determining the Language of an Element
- xmlns prefix (namespace declaration), Namespaces
- XMLSpy, Processing Scenarios
- XPath, XQuery and XPath
- XPath Functions Namespace, Function Names, Predeclared Namespaces, The default function namespace declaration, Built-in Function Reference
- XPDY errors, External Variables, XPDY0002-XPDY0130
- XPST errors, XML Entity and Character References, Named Function References, XPST0001-XPST0081
- XPTY errors, XPTY0004-XPTY0117
- xqDoc, Using Comments for Documentation
- XQDY errors, Computed Attribute Constructors, Using a map constructor, XQDY0025-XQDY0137
- XQJ (XQuery API for Java), XQuery API for Java (XQJ)
- XQST errors, The Function Name, Assembling Queries from Multiple Modules, Multiple module imports, Schema Imports, The Validate Expression, Version Support, Extension Expressions, XQST0009-XQST0134
- XQSuite, Annotations
- XQTY errors, XQTY0024-XQTY0105
- XQuery
- XQuery API for Java (XQJ), XQuery API for Java (XQJ)
- XQuery Update Facility, XQuery Update Facility
- XQueryX, XQueryX
- xs: namespace prefix, Predeclared Namespaces
- xs: prefix (types), Types, Namespaces and XQuery, Atomic Types
- xs:any (schema wildcard), Assigning Type Annotations to Nodes
- xs:anyAtomicType, Sequence Types, Atomic Types, xs:anyAtomicType
- xs:anySimpleType, xs:anySimpleType
- 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 Date and Time Types, xs:date
- xs:dateTime, The Date and Time Types, xs:dateTime
- xs:dateTimeStamp, The Date and Time Types, xs:dateTimeStamp
- xs:dayTimeDuration, The xs:yearMonthDuration and xs:dayTimeDuration Types, xs:dayTimeDuration
- xs:decimal, The xs:decimal Type, xs:decimal
- xs:double, The xs:float and xs:double Types, xs:double
- xs:duration, The Duration Types, xs:duration
- xs:ENTITIES, xs:ENTITIES
- xs:ENTITY, xs:ENTITY
- xs:error, xs:error
- xs:float, The xs:float and xs:double Types, 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, The xs:integer Type, xs:integer
- xs:language, xs:language
- xs:long, xs:long
- xs:Name, xs:Name
- xs:NCName, xs:NCName
- 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:numeric, Sequence Types, The xs:numeric Type, xs:numeric
- xs:positiveInteger, xs:positiveInteger
- xs:QName, Working with Qualified Names, xs:QName
- xs:short, xs:short
- xs:string, The xs:string Type, xs:string
- xs:time, The Date and Time Types, xs:time
- xs:token, xs:token
- xs:unsignedByte, xs:unsignedByte
- xs:unsignedInt, xs:unsignedInt
- xs:unsignedLong, xs:unsignedLong
- xs:unsignedShort, xs:unsignedShort
- xs:untyped, Assigning Type Annotations to Nodes, xs:untyped
- xs:untypedAtomic, Atomic Values and Types, Assigning Type Annotations to Nodes, xs:untypedAtomic
- xs:yearMonthDuration, The xs:yearMonthDuration and xs:dayTimeDuration Types, xs:yearMonthDuration
- XSD (see XML Schema)
- xsi: namespace prefix, Predeclared Namespaces
- xsi:nil attribute, Empty and nil values, Relational Versus XML Data Models
- xsi:type attribute, Constructing Qualified Names
- XSLT
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.