Making comparisons in XQuery

Explicit & Implicit existential quantification

This example illustrates the logical equivalence between explicit and implicit existential quantification in XQuery. It shows that a `some` expression using the `satisfies` keyword yields the same boolean result as a simpler comparison using the `=` operator against a sequence. The code defines two variables, `$eeq` and `$ieq`, and returns both values to confirm they are identical. No external libraries are used; the example relies solely on the built-in XQuery 3.0 language constructs for sequence comparison and quantification.

74% match

Existential Quantification in XQuery

Two XQuery expressions demonstrate existential and universal quantification over a list of author names. The first uses `every ... satisfies` to test whether all names lack a period, while the second uses `some ... satisfies` to check if at least one contains a period. Both queries evaluate against four string literals, showing how XQuery’s quantified expressions return boolean results. The embedded visual likely contrasts the two outcomes with a simple layout, though no charting library appears in the code snippets.

72% match

Combining Node Sequences

Two XQuery scripts demonstrate sequence operations on XML nodes. The first script, `except.xqy`, constructs a `<stopwords>` element from a word list and removes the fourth word using the `except` operator, returning a filtered sequence. The second, `operators.xqy`, defines three sequences of `<name>` elements and applies `except` to compare them, isolating differences between node sequences. Both rely on XQuery 3.1’s sequence operators (`except`, union, intersect) to combine and subtract node sets. The examples highlight how node identity and order determine sequence subtraction, with output shown as XML fragments without external libraries.

65% match

Order by & Group by in XQuery

This example demonstrates how XQuery’s `order by` and `group by` clauses transform an XML book list into grouped output. It shows the difference between sorting titles alphabetically and then grouping them by their `class` attribute, so fiction and nonfiction categories each contain their titles in order. The code defines a `books` element with five `book` children, then iterates with a `for` loop, assigns the text and class via `let`, sorts by title, and groups by class. The result returns the class followed by its titles, revealing how grouping interacts with pre-sorting. No external libraries are used, only the XQuery language’s core expressions.

62% match

Problem 6 of 99 Problems (adapted from https://johncrane.gitbooks.io/ninety-nine-elm-problems/content/p/p06.html)

This example demonstrates a unit test suite for a palindrome-checking function written in XQuery, using the BaseX XQUnit testing framework. It shows how `fn:deep-equal` and `fn:reverse` from the XQuery 3.1 standard library verify that sequences of items (including numbers and strings) read identically forward and backward. The test cases, defined with `%unit:test` annotations and `unit:assert-equals`, cover positive and negative cases, single-item and empty sequences, and string-element palindromes. The code is organized as a module with a namespace and imported test module, reflecting a modular approach to test-driven development.

Quicksort in XQuery

This visualization compares four XQuery implementations of the quicksort algorithm, each derived from a Haskell reference, to demonstrate functional programming in a query language. It shows how the same recursive sorting logic can be expressed with different XQuery 3.1 features, including `fn:head()`, `fn:tail()`, `position()`, and a random-number generator for permutation. The code uses `local:qsort` functions with `xs:integer*` sequences, and the final example applies the sort to a shuffled list of 1 to 100 generated via `fn:random-number-generator('permute')`. The display highlights syntactical variations, such as explicit `where` clauses versus nested `if` expressions, without altering the core algorithm.

<title>Testing XPath

This example demonstrates how XPath and the XQuery `typeswitch` expression can be used to selectively process different node types in an XML document. It shows a TEI-encoded text where comments, text nodes, and `<p>` elements are handled distinctly, with element attributes joined into a space-separated string. The code relies on the XQuery 3.0 standard library functions `fn:string` and `fn:string-join`, operating on the TEI namespace declared in the document. The visualization is static, with no graphical rendering; instead, it highlights the programmatic traversal and conditional branching over the XML tree structure.

Example of grouping and counting in XQuery

This example demonstrates how to group XML elements by an attribute value and count the grouped items using XQuery 3.1’s `group by` clause. It defines a small in-memory `<books>` dataset with five book titles categorized by `class` attributes (fiction or nonfiction). The query iterates over each `<book>`, extracts the text content as titles, and groups them by class, then returns a new element named after each class containing an ordered, numbered list of titles. The implementation relies on XQuery’s `element` constructor and `count` clause to generate the output, with titles sorted alphabetically using `order by`.