Explicit & Implicit existential quantification

100%

Explicit & Implicit existential quantification

✓ Published0🌍 Public

Last edited Jun 20, 2014

Created on Jun 20, 2014

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Making comparisons in XQuery

XQuery’s comparison operators are demonstrated through paired queries that contrast general comparisons with existential quantifiers. The code uses the XQuery `some`/`every` expressions and `satisfies` clauses to test set membership, while `=` and `eq` show value-based versus sequence-based equality. The examples, sourced from a gist, handle XML data with `isbn` attributes and use `where` clauses with `@num` comparisons. A node identity check via the `is` operator highlights how XQuery distinguishes node identity from value equality, all rendered in concise .xqy files.

CCliffordAnderson

74% match

Loading thumbnail…

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.

CCliffordAnderson

73% match

Loading thumbnail…

Simple examples of higher-order functions and partial function application in XQuery

This example demonstrates higher-order functions and partial application in XQuery 3.0, using code tested with Saxon and Zorba. It shows functions that accept or return other functions, such as `local:pow` returning a function, and the `math:pow#2` built-in being partially applied with `?`. The code also illustrates fold operations (`fold-left`, `fold-right`) and sequence functions (`for-each`, `for-each-pair`, `filter`), applied to string and integer sequences. These snippets highlight how XQuery 3.0 supports functional programming patterns.

CCliffordAnderson

54% match

Loading thumbnail…

The Euclidean Algorithm in XQuery

This example demonstrates two implementations of the Euclidean algorithm in XQuery, computing the greatest common divisor of 13 and 8. The first function, `local:euclid`, uses repeated subtraction, while the second, `local:gcd`, employs the more efficient division-and-remainder method. Both functions return the result as an `xs:integer*` sequence using XQuery’s built-in arithmetic and type declarations. The code is drawn from a gist by CliffordAnderson and serves as a minimal, functional illustration of algorithmic logic in a query language.

CCliffordAnderson

53% match

Loading thumbnail…

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.

CCliffordAnderson

53% match

Loading thumbnail…

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.

CCliffordAnderson

52% match

Loading thumbnail…

Eval example

This example demonstrates how to dynamically generate and execute XQuery code at runtime, using the `xquery:eval` function to apply a chosen string function to book titles from an XML collection. The code first iterates over `fn:collection("books")/record/Title` to retrieve each title, then constructs a string expression that calls the external `fn:upper-case` function, passing the current title as a variable. It explicitly shows the use of the XQuery 3.1 standard, the `map` constructor for passing external variables, and the `declare variable $title external` declaration to inject the title into the evaluated expression. The example highlights dynamic code generation within a database query context, with the rendering limited to the function’s output.

CCliffordAnderson

51% match

Loading thumbnail…

Playing with Higher Order Functions in XQuery

This example demonstrates how higher-order functions in XQuery 3.1 enable function composition for transforming numeric sequences. It shows a square function (`$map-sqr`) that uses the simple map operator (`!`) with `math:pow`, which is then fed into a reversal function (`$pow-rev`) via the `=>` arrow operator. The code applies `fn:reverse` to the input sequence before passing it to the squared map, returning the squares of the reversed order. The rendered output is computed in-memory with no external data source, purely exercising the language’s functional capabilities.

CCliffordAnderson

50% match