XQuery. Search Across a Variety of XML Data. 2nd Edition

Spis treści książki

• Preface
  • Contents of This Book
  • Reading the Syntax Diagrams
  • Conventions Used in This Book
  • Using Code Examples
  • Useful Functions
  • Safari Books Online
  • Wed Like to Hear from You
  • Acknowledgments
• 1. Introduction to XQuery
  • What Is XQuery?
    • Capabilities of XQuery
    • Uses for XQuery
    • Processing Scenarios
  • Easing into XQuery
  • Path Expressions
  • FLWORs
  • Adding XML Elements and Attributes
    • Adding Elements
    • Adding Attributes
  • Functions
  • Joins
  • Aggregating and Grouping Values
• 2. XQuery Foundations
  • The Design and History of the XQuery Language
  • XQuery in Context
    • XQuery and XPath
    • XQuery Versus XSLT
    • XQuery Versus SQL
    • XQuery and XML Schema
  • Processing Queries
    • Input Documents
    • The Query
    • The Context
    • The Query Processor
    • The Results of the Query
  • The XQuery Data Model
    • Nodes
      • Node kinds
      • The node hierarchy
      • The node family
      • Roots, documents, and elements
      • Node identity and name
      • String and typed values of nodes
    • Atomic Values
    • Sequences
  • Types
  • Namespaces
• 3. Expressions: XQuery Building Blocks
  • Categories of Expressions
  • Keywords and Names
  • Whitespace in Queries
  • Literals
  • Variables
  • Function Calls
  • Comments
  • Precedence and Parentheses
  • Comparison Expressions
    • General Comparisons
      • General comparisons on multi-item sequences
      • General comparisons and types
    • Value Comparisons
    • Node Comparisons
  • Conditional (if-then-else) Expressions
    • Conditional Expressions and Effective Boolean Value
    • Nesting Conditional Expressions
  • Switch Expressions
  • Logical (and/or) Expressions
    • Precedence of Logical Expressions
    • Negating a Boolean Value
• 4. Navigating XML by Using Paths
  • Path Expressions
    • Path Expressions and Context
      • Steps and changing context
    • Steps
    • Axes
    • Node Tests
      • Node name tests
      • Node name tests and namespaces
      • Node name tests and wildcards
      • Node kind tests
    • Abbreviated Syntax
    • Other Expressions as Steps
  • Predicates
    • Comparisons in Predicates
    • Using Positions in Predicates
      • Understanding positional predicates
      • The position and last functions
      • Positional predicates and reverse axes
    • Using Multiple Predicates
    • More Complex Predicates
  • A Closer Look at Context
    • Working with the Context Node
    • Accessing the Root
  • Dynamic Paths
  • The Simple Map Operator
• 5. Adding Elements and Attributes to Results
  • Including Elements and Attributes from the Input Document
  • Direct Element Constructors
    • Containing Literal Characters
    • Containing Other Element Constructors
    • Containing Enclosed Expressions
      • Enclosed expressions that evaluate to elements
      • Enclosed expressions that evaluate to attributes
      • Enclosed expressions that evaluate to atomic values
      • Enclosed expressions with multiple sub-expressions
    • Specifying Attributes Directly
    • 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
  • Computed Constructors
    • Computed Element Constructors
      • Names of computed element constructors
      • Content of computed element constructors
    • Computed Attribute Constructors
    • Use Case: Turning Content to Markup
• 6. Selecting and Joining Using FLWORs
  • Selecting with Path Expressions
  • FLWOR Expressions
    • The for Clause
      • Range expressions
      • Multiple for clauses
    • The let Clause
    • The where Clause
    • The return Clause
    • The Scope of Variables
  • Quantified Expressions
    • Binding Multiple Variables
  • Selecting Distinct Values
  • Joins
    • Three-Way Joins
    • Outer Joins
      • Outer joins with allowing empty
    • Joins and Types
• 7. Sorting and Grouping
  • Sorting in XQuery
    • The order by Clause
      • Using multiple ordering specifications
      • Sorting and types
      • Order modifiers
      • Empty order
      • Stable ordering
      • More complex order specifications
    • The sort Function
    • Document Order
      • Document order defined
      • Sorting in document order
      • Inadvertent re-sorting in document order
    • Document Order Comparisons
    • Reversing the Order
    • Indicating That Order Is Not Significant
      • The unordered function
      • The unordered expression
      • The ordering mode declaration
  • Grouping
    • Grouping Using the group by Clause
      • Grouping on multiple values
      • More complex grouping specifications
  • Aggregating Values
    • Ignoring Missing Values
    • Counting Missing Values
    • Aggregating on Multiple Values
    • Constraining and Sorting on Aggregated Values
• 8. Functions
  • Built-in Versus User-Defined Functions
  • Calling Functions
    • Function Names
    • Function Signatures
    • Argument Lists
      • Argument lists and the empty sequence
      • Argument lists and sequences
    • Sequence Types
    • Calling Functions with the Arrow Operator
  • User-Defined Functions
    • Why Define Your Own Functions?
    • Function Declarations
    • The Function Body
    • The Function Name
    • The Parameter List
      • Accepting arguments that are nodes versus atomic values
      • Accepting arguments that are the empty sequence
    • Functions and Context
    • Recursive Functions
• 9. Advanced Queries
  • Working with Positions and Sequence Numbers
    • Adding Sequence Numbers to Results
    • Using the count Clause
    • Testing for the Last Item
  • Windowing
    • Using start and end Conditions
    • Windows Based on Position
    • Windows Based on Previous or Next Items
    • Sliding Windows
  • Copying Input Elements with Modifications
    • Adding Attributes to an Element
    • Removing Attributes from an Element
    • Removing Attributes from All Descendants
    • Removing Child Elements
    • Changing Names
  • Combining Results
    • Sequence Constructors
    • The union Expression
    • The intersect Expression
    • The except Expression
  • Using Intermediate XML Documents
    • Creating Lookup Tables
    • Reducing Complexity
• 10. Namespaces and XQuery
  • XML Namespaces
    • Namespace URIs
    • Declaring Namespaces
    • Default Namespace Declarations
    • Namespaces and Attributes
    • Namespace Declarations and Scope
  • Namespaces and XQuery
  • Namespace Declarations in Queries
    • Predeclared Namespaces
    • Prolog Namespace Declarations
      • Default namespace declarations in the prolog
      • The default function namespace declaration
      • Other prolog namespace declarations
    • Namespace Declarations in Direct Element Constructors
    • Namespace Declarations in Computed Constructors
    • The Impact and Scope of Namespace Declarations
      • Scope of namespace declarations
      • Names affected by namespace declarations
      • Namespace declarations and input elements
  • Controlling Namespace Declarations in Your Results
    • In-Scope Versus Statically Known Namespaces
    • Controlling the Copying of Namespace Declarations
  • URI-Qualified Names
• 11. A Closer Look at Types
  • The XQuery Type System
    • Advantages of a Strong Type System
    • Do You Need to Care About Types?
  • The Built-in Types
    • Atomic Types
    • List Types
    • Union Types
  • Types, Nodes, and Atomic Values
    • Nodes and Types
    • Atomic Values and Types
  • Type Checking in XQuery
    • The Static Analysis Phase
    • The Dynamic Evaluation Phase
  • Automatic Type Conversions
    • Subtype Substitution
    • Type Promotion
    • Casting of Untyped Values
    • Atomization
    • Effective Boolean Value
    • Function Conversion Rules
  • Sequence Types
    • Occurrence Indicators
    • Generic Sequence Types
    • Simple Type Names as Sequence Types
    • Element and Attribute Tests
    • Sequence Type Matching
    • The instance of Expression
  • Constructors and Casting
    • Constructors
    • The Cast Expression
    • The Castable Expression
    • Casting Rules
      • Casting among the primitive types
      • Casting from xs:string or xs:untypedAtomic
      • Casting to xs:string or xs:untypedAtomic
      • Casting among derived types
• 12. Prologs, Modules, and Variables
  • Structure of a Query: Prolog and Body
    • Prolog Declarations
    • The Version Declaration
  • Assembling Queries from Multiple Modules
    • Library Modules
    • Importing a Library Module
      • Multiple module imports
      • Multi-level imports
    • Loading a Library Module Dynamically
  • Variable Declarations
    • Variable Declaration Syntax
    • The Scope of Variables
    • Variable Names
    • Initializing Expressions
    • External Variables
  • Private Functions and Variables
  • Declaring External Functions
• 13. Inputs and Outputs
  • Types of Input and Output Documents
  • Accessing Input Documents
    • Accessing a Single Document with a Function
      • Resolving URIs of input documents
    • Accessing a Collection
    • Setting the Context Outside the Query
    • Using Variables
    • Setting the Context in the Prolog
  • Serializing Output
    • Serialization Methods
    • Serialization Parameters
    • Specifying Serialization Parameters by Using Option Declarations
    • Specifying Serialization Parameters by Using a Separate XML Document
    • Serialization Errors
    • Serializing to a String
• 14. Using Schemas with XQuery
  • What Is a Schema?
  • Why Use Schemas with Queries?
  • W3C XML Schema: A Brief Overview
    • Element and Attribute Declarations
    • Types
      • Simple and complex types
      • User-defined types
      • List types
    • Namespaces and XML Schema
  • In-Scope Schema Definitions
    • Where Do In-Scope Schema Definitions Come From?
    • Schema Imports
      • Importing a schema with no target namespace
      • Importing multiple schemas with the same target namespace
      • Schema imports and library modules
  • Schema Validation and Type Assignment
    • The Validate Expression
    • Validation Mode
    • Assigning Type Annotations to Nodes
    • Nodes and Typed Values
    • Types and Newly Constructed Elements and Attributes
  • Sequence Types and Schemas
• 15. Static Typing
  • What Is Static Typing?
    • Obvious Static Type Errors
    • Static Typing and Schemas
    • Raising False Errors
    • Static Typing Expressions and Constructs
  • The Typeswitch Expression
  • The Treat Expression
  • Type Declarations
    • Type Declarations in FLWORs
    • Type Declarations in Quantified Expressions
    • Type Declarations in Global Variable Declarations
  • The zero-or-one, one-or-more, and exactly-one Functions
• 16. Writing Better Queries
  • Query Design Goals
  • Clarity
    • Improving the Layout
    • Choosing Names
    • Using Comments for Documentation
  • Modularity
  • Robustness
    • Handling Data Variations
    • Handling Missing Values
      • Absent values
      • Empty and nil values
      • Default missing values
  • Error Handling
    • Avoiding Dynamic Errors
    • The error and trace Functions
    • Try/Catch Expressions
  • Performance
    • Avoid Reevaluating the Same or Similar Expressions
    • Avoid Unnecessary Sorting
    • Avoid Expensive Path Expressions
    • Use Predicates Instead of where Clauses
• 17. Working with Numbers
  • The Numeric Types
    • The xs:decimal Type
    • The xs:integer Type
    • The xs:float and xs:double Types
    • The xs:numeric Type
  • Constructing Numeric Values
    • The number Function
    • Numeric Type Promotion
  • Comparing Numeric Values
  • Arithmetic Operations
    • Arithmetic Operations on Multiple Values
    • Arithmetic Operations and Types
    • Precedence of Arithmetic Operators
    • Addition, Subtraction, and Multiplication
    • Division
    • Modulus (Remainder)
  • Functions on Numbers
  • Formatting Numbers
    • Formatting Integers
    • Formatting Decimal Numbers
    • The Decimal Format Declaration
• 18. Working with Strings
  • The xs:string Type
  • Constructing Strings
    • String Literals
    • The xs:string Constructor and the string Function
  • Comparing Strings
    • Comparing Entire Strings
    • Determining Whether a String Contains Another String
    • Matching a String to a Pattern
  • Substrings
  • Finding the Length of a String
  • Concatenating and Splitting Strings
    • Concatenating Strings
    • Splitting Strings Apart
    • Converting Between Codepoints and Strings
  • Manipulating Strings
    • Converting Between Uppercase and Lowercase
    • Replacing Individual Characters in Strings
    • Replacing Substrings That Match a Pattern
  • Whitespace and Strings
    • Normalizing Whitespace
  • Internationalization Considerations
    • Collations
      • Supported collations
      • Specifying a collation
    • Unicode Normalization
    • Determining the Language of an Element
• 19. Regular Expressions
  • The Structure of a Regular Expression
    • Atoms
    • Quantifiers
    • Parenthesized Sub-Expressions and Branches
  • Representing Individual Characters
  • Representing Any Character
  • Representing Groups of Characters
    • Multi-Character Escapes
    • Category Escapes
    • Block Escapes
  • Character Class Expressions
    • Single Characters and Ranges
    • Subtraction from a Range
    • Negative Character Class Expressions
    • Escaping Rules for Character Class Expressions
  • Reluctant Quantifiers
  • Anchors
  • Back-References
  • Using Flags
  • Using Sub-Expressions with Replacement Variables
• 20. Working with Dates, Times, and Durations
  • The Date and Time Types
    • Constructing and Casting Dates and Times
    • Time Zones
      • Explicit versus implicit time zones
      • Adjusting time zones
      • Finding the time zone of a value
    • Comparing Dates and Times
  • The Duration Types
    • The xs:yearMonthDuration and xs:dayTimeDuration Types
    • Comparing Durations
  • Extracting Components of Dates, Times, and Durations
  • Formatting Dates and Times
  • Using Arithmetic Operators on Dates, Times, and Durations
    • Subtracting Dates and Times
    • Adding and Subtracting Durations from Dates and Times
    • Adding and Subtracting Two Durations
    • Multiplying and Dividing Durations by Numbers
    • Dividing Durations by Durations
  • The Date Component Types
• 21. Working with Qualified Names, URIs, and IDs
  • Working with Qualified Names
    • Retrieving Node Names
    • Constructing Qualified Names
    • Other Name-Related Functions
  • Working with URIs
    • Base and Relative URIs
      • Using the xml:base attribute
      • Finding the base URI of a node
      • Resolving URIs
      • Static base URI
    • Documents and URIs
      • Finding the URI of a document
      • Opening a document from a dynamic value
    • Escaping URIs
  • Working with IDs
    • Joining IDs and IDREFs
    • Constructing ID Attributes
    • Generating Unique ID Values
• 22. Working with Other XML Constructs
  • XML Comments
    • XML Comments and the Data Model
    • Querying Comments
    • Comments and Sequence Types
    • Constructing Comments
  • Processing Instructions
    • Processing Instructions and the Data Model
    • Querying Processing Instructions
    • Processing Instructions and Sequence Types
    • Constructing Processing Instructions
  • Documents
    • Document Nodes and the Data Model
    • Document Nodes and Sequence Types
    • Constructing Document Nodes
  • Text Nodes
    • Text Nodes and the Data Model
    • Querying Text Nodes
    • Text Nodes and Sequence Types
    • Why Work with Text Nodes?
    • Constructing Text Nodes
  • XML Entity and Character References
  • CDATA Sections
• 23. Function Items and Higher-Order Functions
  • Why Higher-Order Functions?
  • Constructing Functions and Calling Them Dynamically
    • Named Function References
    • Using function-lookup to Obtain a Function
    • Inline Function Expressions
    • Partial Function Application
    • The Arrow Operator and Dynamic Function Calls
    • Syntax Recap
  • Functions and Sequence Types
  • Higher-Order Functions
    • Built-In Higher-Order Functions
    • Writing Your Own Higher-Order Functions
• 24. Maps, Arrays, and JSON
  • Maps
    • Constructing Maps
      • Using a map constructor
      • Using map:entry and map:merge to create maps
    • Looking Up Map Values
      • Using the map:get function
      • Invoking maps as functions
      • Using the lookup operator on maps
    • Querying Maps
    • Changing Maps
    • Iterating over Entries in a Map
    • Maps and Sequence Types
  • Arrays
    • Constructing Arrays
    • Arrays Versus Sequences
    • Arrays and Atomization
    • Looking Up Array Values
      • Using the array:get function
      • Invoking arrays as functions
      • Using the lookup operator on arrays
    • Querying Arrays
    • Changing Arrays
    • Arrays and Sequence Types
  • JSON
    • Parsing JSON
    • Serializing JSON
    • Converting Between JSON and XML
• 25. Implementation-Specific Features
  • Conformance
  • Version Support
    • New Features in XQuery 3.0
    • New Features in XQuery 3.1
  • Setting the Query Context
  • The Option Declaration
  • Extension Expressions
  • Annotations
• 26. XQuery for SQL Users
  • Relational Versus XML Data Models
  • Comparing SQL Syntax with XQuery Syntax
    • A Simple Query
    • Conditions and Operators
      • Comparisons
      • Arithmetic operators
      • Boolean operators
    • Functions
    • Selecting Distinct Values
    • Working with Multiple Tables and Subqueries
      • Subselects
      • Combining queries by using set operators
    • Grouping
  • Combining SQL and XQuery
    • Combining Structured and Semi-Structured Data
    • Flexible Data Structures
  • SQL/XML
• 27. XQuery for XSLT Users
  • XQuery and XPath
  • XQuery Versus XSLT
    • Shared Components
    • Equivalent Components
    • Differences
      • Paradigm differences: push versus pull
      • Optimization for particular use cases
      • Convenient features of XSLT
  • Using XQuery and XSLT Together
  • XQuery Backward Compatibility with XPath 1.0
    • Data Model
    • New Expressions
    • Path Expressions
    • Function Conversion Rules
    • Arithmetic and Comparison Expressions
    • Built-in Functions
• 28. Additional XQuery-Related Standards
  • XQuery Update Facility
  • Full-Text Search
  • XQueryX
  • RESTXQ
  • XQuery API for Java (XQJ)
• A. Built-in Function Reference
• B. Built-in Types
  • xs:anyAtomicType
  • xs:anySimpleType
  • xs:anyType
  • xs:anyURI
    • Casting and Comparing xs:anyURI Values
  • xs:base64Binary
  • xs:boolean
    • Constructing xs:boolean Values
    • Casting xs:boolean Values
  • xs:byte
  • xs:date
  • xs:dateTime
  • xs:dateTimeStamp
  • xs:dayTimeDuration
  • xs:decimal
    • Casting xs:decimal Values
  • xs:double
    • Casting xs:double Values
  • xs:duration
  • xs:ENTITIES
  • xs:ENTITY
  • xs:error
  • xs:float
    • Casting xs:float Values
  • xs:gDay
  • xs:gMonth
  • xs:gMonthDay
  • xs:gYear
  • xs:gYearMonth
  • xs:hexBinary
  • xs:ID
  • xs:IDREF
  • xs:IDREFS
  • xs:int
  • xs:integer
    • Casting xs:integer Values
  • xs:language
  • xs:long
  • xs:Name
  • xs:NCName
  • xs:negativeInteger
  • xs:NMTOKEN
  • xs:NMTOKENS
  • xs:nonNegativeInteger
  • xs:nonPositiveInteger
  • xs:normalizedString
  • xs:NOTATION
  • xs:numeric
  • xs:positiveInteger
  • xs:QName
  • xs:short
  • xs:string
  • xs:time
  • xs:token
  • xs:unsignedByte
  • xs:unsignedInt
  • xs:unsignedLong
  • xs:unsignedShort
  • xs:untyped
  • xs:untypedAtomic
  • xs:yearMonthDuration
• C. Error Summary
  • FOAP0001
  • FOAR0001
  • FOAR0002
  • FOAY0001
  • FOAY0002
  • FOCA0001
  • FOCA0002
  • FOCA0003
  • FOCA0005
  • FOCA0006
  • FOCH0001
  • FOCH0002
  • FOCH0003
  • FOCH0004
  • FODC0001
  • FODC0002
  • FODC0003
  • FODC0004
  • FODC0005
  • FODC0006
  • FODC0010
  • FODF1280
  • FODF1310
  • FODT0001
  • FODT0002
  • FODT0003
  • FOER0000
  • FOFD1340
  • FOFD1350
  • FOJS0001
  • FOJS0003
  • FOJS0004
  • FOJS0005
  • FOJS0006
  • FOJS0007
  • FONS0004
  • FONS0005
  • FOQM0001
  • FOQM0002
  • FOQM0003
  • FOQM0004
  • FOQM0005
  • FOQM0006
  • FORG0001
  • FORG0002
  • FORG0003
  • FORG0004
  • FORG0005
  • FORG0006
  • FORG0008
  • FORG0009
  • FORG0010
  • FORX0001
  • FORX0002
  • FORX0003
  • FORX0004
  • FOTY0012
  • FOTY0013
  • FOTY0014
  • FOTY0015
  • FOUT1170
  • FOUT1190
  • FOUT1200
  • FOXT0001
  • FOXT0002
  • FOXT0003
  • FOXT0004
  • SENR0001
  • SEPM0004
  • SEPM0009
  • SEPM0010
  • SEPM0016
  • SEPM0017
  • SEPM0018
  • SEPM0019
  • SERE0003
  • SERE0005
  • SERE0006
  • SERE0008
  • SERE0012
  • SERE0014
  • SERE0015
  • SERE0020
  • SERE0021
  • SERE0022
  • SERE0023
  • SESU0007
  • SESU0011
  • SESU0013
  • XPDY0002
  • XPDY0050
  • XPDY0130
  • XPST0001
  • XPST0003
  • XPST0005
  • XPST0008
  • XPST0017
  • XPST0051
  • XPST0080
  • XPST0081
  • XPTY0004
  • XPTY0018
  • XPTY0019
  • XPTY0020
  • XPTY0117
  • XQDY0025
  • XQDY0026
  • XQDY0027
  • XQDY0041
  • XQDY0044
  • XQDY0054
  • XQDY0061
  • XQDY0064
  • XQDY0072
  • XQDY0074
  • XQDY0084
  • XQDY0091
  • XQDY0092
  • XQDY0096
  • XQDY0101
  • XQDY0102
  • XQDY0137
  • XQST0009
  • XQST0012
  • XQST0013
  • XQST0016
  • XQST0022
  • XQST0031
  • XQST0032
  • XQST0033
  • XQST0034
  • XQST0035
  • XQST0038
  • XQST0039
  • XQST0040
  • XQST0045
  • XQST0046
  • XQST0047
  • XQST0048
  • XQST0049
  • XQST0052
  • XQST0055
  • XQST0057
  • XQST0058
  • XQST0059
  • XQST0060
  • XQST0065
  • XQST0066
  • XQST0067
  • XQST0068
  • XQST0069
  • XQST0070
  • XQST0071
  • XQST0075
  • XQST0076
  • XQST0079
  • XQST0085
  • XQST0087
  • XQST0088
  • XQST0089
  • XQST0090
  • XQST0094
  • XQST0097
  • XQST0098
  • XQST0099
  • XQST0103
  • XQST0104
  • XQST0106
  • XQST0108
  • XQST0109
  • XQST0110
  • XQST0111
  • XQST0113
  • XQST0114
  • XQST0115
  • XQST0116
  • XQST0118
  • XQST0119
  • XQST0125
  • XQST0129
  • XQST0134
  • XQTY0024
  • XQTY0030
  • XQTY0086
  • XQTY0105
• Index

pokaż cały spis treści

ukryj recenzje