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

(ebook) (audiobook) (audiobook)

Promocja Przejdź

XQuery. Search Across a Variety of XML Data. 2nd Edition Priscilla Walmsley - okladka książki

XQuery. Search Across a Variety of XML Data. 2nd Edition Priscilla Walmsley - audiobook MP3

XQuery. Search Across a Variety of XML Data. 2nd Edition Priscilla Walmsley - audiobook CD

Autor:: Priscilla Walmsley
Wydawnictwo:: O'Reilly Media (Z chęcią przeczytam książkę w języku polskim)
Ocena:: Bądź pierwszym, który oceni tę książkę
Stron:: 762
Dostępne formaty:: ePub

Mobi

Ebook (160,65 zł najniższa cena z 30 dni)

~~189,00 zł~~ (-15%)
160,65 zł

Dodaj do koszyka lub Kup na prezent Kup 1-kliknięciem

(160,65 zł najniższa cena z 30 dni)

Przenieś na półkę

Do przechowalni

The W3C XQuery 3.1 standard provides a tool to search, extract, and manipulate content, whether it's in XML, JSON or plain text. With this fully updated, in-depth tutorial, you’ll learn to program with this highly practical query language.

Designed for query writers who have some knowledge of XML basics, but not necessarily advanced knowledge of XML-related technologies, this book is ideal as both a tutorial and a reference. You’ll find background information for namespaces, schemas, built-in types, and regular expressions that are relevant to writing XML queries.

This second edition provides:

A high-level overview and quick tour of XQuery
New chapters on higher-order functions, maps, arrays, and JSON
A carefully paced tutorial that teaches XQuery without being bogged down by the details
Advanced concepts for taking advantage of modularity, namespaces, typing, and schemas
Guidelines for working with specific types of data, such as numbers, strings, dates, URIs, maps and arrays
XQuery’s implementation-specific features and its relationship to other standards including SQL and XSLT
A complete alphabetical reference to the built-in functions, types, and error messages

Wybrane bestsellery

Ebooka "XQuery. Search Across a Variety of XML Data. 2nd Edition" przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook, Onyx Booxs i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Audiobooka "XQuery. Search Across a Variety of XML Data. 2nd Edition" posłuchasz:

w aplikacji Ebookpoint na Android, iOS, HarmonyOs
na systemach Windows, MacOS i innych

na dowolonych urządzeniach
i aplikacjach obsługujących format MP3
(pliki spakowane w ZIP)

Masz pytania? Zajrzyj do zakładki Pomoc »

Kurs Video "XQuery. Search Across a Variety of XML Data. 2nd Edition" zobaczysz:

Oceny i opinie klientów: XQuery. Search Across a Variety of XML Data. 2nd Edition Priscilla Walmsley (0) Weryfikacja opinii następuję na podstawie historii zamówień na koncie Użytkownika umieszczającego opinię.

Szczegóły książki

ISBN Ebooka:: 978-14-919-1511-0, 9781491915110
Data wydania ebooka :: 2015-12-02 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@helion.pl.
Język publikacji:: angielski
Rozmiar pliku ePub:: 3.6MB
Rozmiar pliku Mobi:: 9.6MB

Zgłoś erratę
Kategorie:
Technologie webowe » XML i XSLT - Programowanie

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