v2 RC1 Changes (#7)

- Changes `items` and `hasItems` on `DocumentList` to be properties
- Updates dependent option/result library, which contains similar changes

Reviewed-on: #7

README.md

@@ -4,15 +4,19 @@ This library allows SQLite and PostgreSQL to be treated as document databases. I
 
 ## Add via Composer
 
-[![Packagist Version](https://img.shields.io/packagist/v/bit-badger/pdo-document)](https://packagist.org/packages/bit-badger/pdo-document)
+[![Static Badge](https://img.shields.io/badge/v1.0.0--rc1-orange?label=php%208.2)
+](https://packagist.org/packages/bit-badger/pdo-document#v1.0.0-rc1)     [![Packagist Version](https://img.shields.io/packagist/v/bit-badger/pdo-document?include_prereleases&label=php%208.4)
+](https://packagist.org/packages/bit-badger/pdo-document)
 
 `composer require bit-badger/pdo-document`
 
+For the v1 series, the `DocumentList` type's members `hasItems` and `items` are functions; in the v2 series, they are properties. Additionally, the `Option` and `Result` types included in the project have a similar difference; see the [v1 README](https://git.bitbadger.solutions/bit-badger/inspired-by-fsharp/src/branch/v1/README.md) for PHP 8.2 or 8.3 and the [v2 README](https://git.bitbadger.solutions/bit-badger/inspired-by-fsharp/src/branch/main/README.md) for PHP 8.4. Both versions are supported; the v1 / v2 distinction helps composer make the right choice based on the target PHP version of your project.
+
 ## Configuration
 
 ### Connection Details
 
-The static variable `Configuration::$pdoDSN` must be set to the [PDO data source name](https://www.php.net/manual/en/pdo.construct.php#refsect1-pdo.construct-parameters) for your database. `Configuration` also has `$username`, `$password`, and `$options` variables that will be used to construct the PDO object it will use for data access.
+The [PDO data source name](https://www.php.net/manual/en/pdo.construct.php#refsect1-pdo.construct-parameters) must be provided via `Configuration::useDSN()`. `Configuration` also has `$username`, `$password`, and `$options` variables that will be used to construct the PDO object it will use for data access.
 
 ### Document Identifiers
 
@@ -29,4 +33,4 @@ In all generated scenarios, if the ID value is not 0 or blank, that ID will be u
 
 ## Usage
 
-Documentation for this library is not complete (writing it is one of the goals before the “beta” tag is dropped); however, its structure is very similar to the .NET version, so [its documentation will help](https://bitbadger.solutions/open-source/relational-documents/basic-usage.html) until its project specific documentation is developed. Things like `Count.All()` become `Count::all`, and all the `byField` operations are named `byFields` and take an array of fields.
+Full documentation [is available on the project site](https://bitbadger.solutions/open-source/pdo-document/).

composer.json

@@ -1,7 +1,7 @@
 {
   "name": "bit-badger/pdo-document",
-  "description": "Treat SQLite (and soon PostgreSQL) as a document store",
-  "keywords": ["database", "document", "sqlite", "pdo"],
+  "description": "Treat SQLite and PostgreSQL as document stores",
+  "keywords": ["database", "document", "sqlite", "pdo", "postgresql"],
   "license": "MIT",
   "authors": [
     {
@@ -14,15 +14,20 @@
   "support": {
     "email": "daniel@bitbadger.solutions",
     "source": "https://git.bitbadger.solutions/bit-badger/pdo-document",
-    "rss": "https://git.bitbadger.solutions/bit-badger/pdo-document.rss"
+    "rss": "https://git.bitbadger.solutions/bit-badger/pdo-document.rss",
+    "docs": "https://bitbadger.solutions/open-source/pdo-document/"
   },
+  "minimum-stability": "RC",
   "require": {
-    "php": ">=8.2",
+    "php": ">=8.4",
+    "bit-badger/inspired-by-fsharp": "^2",
     "netresearch/jsonmapper": "^4",
     "ext-pdo": "*"
   },
   "require-dev": {
-    "phpunit/phpunit": "^11"
+    "phpunit/phpunit": "^11",
+    "square/pjson": "^0.5.0",
+    "phpstan/phpstan": "^1.12"
   },
   "autoload": {
     "psr-4": {
@@ -33,6 +38,7 @@
   },
   "autoload-dev": {
     "psr-4": {
+      "Test\\": "./tests",
       "Test\\Unit\\": "./tests/unit",
       "Test\\Integration\\": "./tests/integration",
       "Test\\Integration\\PostgreSQL\\": "./tests/integration/postgresql",
@@ -42,4 +48,4 @@
   "archive": {
     "exclude": [ "/tests", "/.gitattributes", "/.gitignore", "/.git", "/composer.lock" ]
   }
-}
+}

src/AutoId.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 

src/Configuration.php

@@ -1,7 +1,15 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
+use BitBadger\InspiredByFSharp\Option;
+use Exception;
 use PDO;
 
 /**
@@ -20,51 +28,78 @@ class Configuration
      */
     public static int $idStringLength = 16;
 
-    /** @var string The data source name (DSN) of the connection string */
-    public static string $pdoDSN = '';
-
     /** @var string|null The username to use to establish a data connection (use env PDO_DOC_USERNAME if possible) */
     public static ?string $username = null;
 
     /** @var string|null The password to use to establish a data connection (use env PDO_DOC_PASSWORD if possible) */
     public static ?string $password = null;
 
-    /** @var array|null Options to use for connections (driver-specific) */
+    /** @var mixed[]|null Options to use for connections (driver-specific) */
     public static ?array $options = null;
 
-    /** @var Mode|null The mode in which the library is operating (filled after first connection if not configured) */
-    public static ?Mode $mode = null;
+    /** @var Option<Mode> The mode in which the library is operating */
+    public static Option $mode;
+
+    /** @var Option<string> The data source name (DSN) of the connection string */
+    private static Option $pdoDSN;
 
     /** @var PDO|null The PDO instance to use for database commands */
-    private static ?PDO $_pdo = null;
+    private static ?PDO $pdo = null;
+
+    /**
+     * Use a Data Source Name (DSN)
+     *
+     * @param string $dsn The data source name to use (driver:[parameters])
+     * @throws DocumentException If a DSN does not start with `pgsql:` or `sqlite:`
+     */
+    public static function useDSN(string $dsn): void
+    {
+        if (empty($dsn)) {
+            self::$mode = self::$pdoDSN = Option::None();
+        } else {
+            self::$mode   = Option::Some(Mode::deriveFromDSN($dsn));
+            self::$pdoDSN = Option::Some($dsn);
+        }
+    }
 
     /**
      * Retrieve a new connection to the database
      *
      * @return PDO A new connection to the SQLite database with foreign key support enabled
-     * @throws DocumentException If this is called before a connection string is set
+     * @throws Exception If this is called before a connection string is set
      */
     public static function dbConn(): PDO
     {
-        if (is_null(self::$_pdo)) {
-            if (empty(self::$pdoDSN)) {
-                throw new DocumentException('Please provide a data source name (DSN) before attempting data access');
-            }
-            self::$_pdo = new PDO(self::$pdoDSN, $_ENV['PDO_DOC_USERNAME'] ?? self::$username,
+        if (is_null(self::$pdo)) {
+            $dsn = self::$pdoDSN->getOrThrow(fn()
+                => new DocumentException('Please provide a data source name (DSN) before attempting data access'));
+            self::$pdo = new PDO($dsn, $_ENV['PDO_DOC_USERNAME'] ?? self::$username,
                 $_ENV['PDO_DOC_PASSWORD'] ?? self::$password, self::$options);
-
-            if (is_null(self::$mode)) {
-                $driver = self::$_pdo->getAttribute(PDO::ATTR_DRIVER_NAME);
-                self::$mode = match ($driver) {
-                    'pgsql' => Mode::PgSQL,
-                    'sqlite' => Mode::SQLite,
-                    default => throw new DocumentException(
-                        "Unsupported driver $driver: this library currently supports PostgreSQL and SQLite")
-                };
-            }
         }
 
-        return self::$_pdo;
+        return self::$pdo;
+    }
+
+    /**
+     * Retrieve the mode for the current database connection
+     *
+     * @return Mode The mode for the current database connection
+     * @throws Exception If the database mode has not been set
+     */
+    public static function mode(?string $process = null): Mode
+    {
+        return self::$mode->getOrThrow(fn()
+            => new DocumentException('Database mode not set' . (is_null($process) ? '' : "; cannot $process")));
+    }
+
+    /**
+     * You probably don't mean to be calling this; it is here for testing only
+     *
+     * @param Mode|null $mode The mode to set
+     */
+    public static function overrideMode(?Mode $mode): void
+    {
+        self::$mode = Option::of($mode);
     }
 
     /**
@@ -72,6 +107,6 @@ class Configuration
      */
     public static function resetPDO(): void
     {
-        self::$_pdo = null;
+        self::$pdo = null;
     }
 }

src/Count.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -25,23 +31,23 @@ class Count
      * Count matching documents using a comparison on JSON fields
      *
      * @param string $tableName The name of the table in which documents should be counted
-     * @param array|Field[] $fields The field comparison to match
+     * @param Field[] $fields The field comparison to match
      * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
      * @return int The count of documents matching the field comparison
      * @throws DocumentException If one is encountered
      */
     public static function byFields(string $tableName, array $fields, ?FieldMatch $match = null): int
     {
-        $namedFields = Parameters::nameFields($fields);
-        return Custom::scalar(Query\Count::byFields($tableName, $namedFields, $match),
-            Parameters::addFields($namedFields, []), new CountMapper());
+        Parameters::nameFields($fields);
+        return Custom::scalar(Query\Count::byFields($tableName, $fields, $match), Parameters::addFields($fields, []),
+            new CountMapper());
     }
 
     /**
      * Count matching documents using a JSON containment query (`@>`; PostgreSQL only)
      *
      * @param string $tableName The name of the table in which documents should be counted
-     * @param array|object $criteria The criteria for the JSON containment query
+     * @param mixed[]|object $criteria The criteria for the JSON containment query
      * @return int The number of documents matching the JSON containment query
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */

src/Custom.php

@@ -1,7 +1,14 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
+use BitBadger\InspiredByFSharp\Option;
 use BitBadger\PDODocument\Mapper\Mapper;
 use PDO;
 use PDOException;
@@ -16,7 +23,7 @@ class Custom
      * Prepare a query for execution and run it
      *
      * @param string $query The query to be run
-     * @param array $parameters The parameters for the query
+     * @param array<string, mixed> $parameters The parameters for the query
      * @return PDOStatement The result of executing the query
      * @throws DocumentException If the query execution is unsuccessful
      */
@@ -38,7 +45,7 @@ class Custom
                 is_bool($value) => PDO::PARAM_BOOL,
                 is_int($value)  => PDO::PARAM_INT,
                 is_null($value) => PDO::PARAM_NULL,
-                default         => PDO::PARAM_STR
+                default         => PDO::PARAM_STR,
             };
             $stmt->bindValue($key, $value, $dataType);
         }
@@ -60,7 +67,7 @@ class Custom
      *
      * @template TDoc The domain type of the document to retrieve
      * @param string $query The query to be executed
-     * @param array $parameters Parameters to use in executing the query
+     * @param array<string, mixed> $parameters Parameters to use in executing the query
      * @param Mapper<TDoc> $mapper Mapper to deserialize the result
      * @return DocumentList<TDoc> The items matching the query
      * @throws DocumentException If any is encountered
@@ -75,14 +82,14 @@ class Custom
      *
      * @template TDoc The domain type of the document to retrieve
      * @param string $query The query to be executed
-     * @param array $parameters Parameters to use in executing the query
+     * @param array<string, mixed> $parameters Parameters to use in executing the query
      * @param Mapper<TDoc> $mapper Mapper to deserialize the result
      * @return TDoc[] The items matching the query
      * @throws DocumentException If any is encountered
      */
     public static function array(string $query, array $parameters, Mapper $mapper): array
     {
-        return iterator_to_array(self::list($query, $parameters, $mapper)->items());
+        return iterator_to_array(self::list($query, $parameters, $mapper)->items);
     }
 
     /**
@@ -90,16 +97,16 @@ class Custom
      *
      * @template TDoc The domain type of the document to retrieve
      * @param string $query The query to be executed (will have "LIMIT 1" appended)
-     * @param array $parameters Parameters to use in executing the query
+     * @param array<string, mixed> $parameters Parameters to use in executing the query
      * @param Mapper<TDoc> $mapper Mapper to deserialize the result
-     * @return false|TDoc The item if it is found, false if not
+     * @return Option<TDoc> A `Some` instance if the item is found, `None` otherwise
      * @throws DocumentException If any is encountered
      */
-    public static function single(string $query, array $parameters, Mapper $mapper): mixed
+    public static function single(string $query, array $parameters, Mapper $mapper): Option
     {
         try {
             $stmt = &self::runQuery("$query LIMIT 1", $parameters);
-            return ($first = $stmt->fetch(PDO::FETCH_ASSOC)) ? $mapper->map($first) : false;
+            return ($first = $stmt->fetch(PDO::FETCH_ASSOC)) ? Option::Some($mapper->map($first)) : Option::None();
         } finally {
             $stmt = null;
         }
@@ -109,7 +116,7 @@ class Custom
      * Execute a query that does not return a value
      *
      * @param string $query The query to execute
-     * @param array $parameters Parameters to use in executing the query
+     * @param array<string, mixed> $parameters Parameters to use in executing the query
      * @throws DocumentException If any is encountered
      */
     public static function nonQuery(string $query, array $parameters): void
@@ -126,7 +133,7 @@ class Custom
      *
      * @template T The scalar type to return
      * @param string $query The query to retrieve the value
-     * @param array $parameters Parameters to use in executing the query
+     * @param array<string, mixed> $parameters Parameters to use in executing the query
      * @param Mapper<T> $mapper The mapper to obtain the result
      * @return mixed|false|T The scalar value if found, false if not
      * @throws DocumentException If any is encountered

src/Definition.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -24,7 +30,7 @@ class Definition
      *
      * @param string $tableName The name of the table which should be indexed
      * @param string $indexName The name of the index
-     * @param array $fields Fields which should be a part of this index
+     * @param string[] $fields Fields which should be a part of this index
      * @throws DocumentException If any is encountered
      */
     public static function ensureFieldIndex(string $tableName, string $indexName, array $fields): void

src/Delete.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -23,22 +29,21 @@ class Delete
      * Delete documents by matching a comparison on JSON fields
      *
      * @param string $tableName The table from which documents should be deleted
-     * @param array|Field[] $fields The field comparison to match
+     * @param Field[] $fields The field comparison to match
      * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
      * @throws DocumentException If any is encountered
      */
     public static function byFields(string $tableName, array $fields, ?FieldMatch $match = null): void
     {
-        $namedFields = Parameters::nameFields($fields);
-        Custom::nonQuery(Query\Delete::byFields($tableName, $namedFields, $match),
-            Parameters::addFields($namedFields, []));
+        Parameters::nameFields($fields);
+        Custom::nonQuery(Query\Delete::byFields($tableName, $fields, $match), Parameters::addFields($fields, []));
     }
 
     /**
      * Delete documents matching a JSON containment query (`@>`; PostgreSQL only)
      *
      * @param string $tableName The table from which documents should be deleted
-     * @param array|object $criteria The JSON containment query values
+     * @param mixed[]|object $criteria The JSON containment query values
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */
     public static function byContains(string $tableName, array|object $criteria): void

src/Document.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -11,14 +17,14 @@ class Document
      * Insert a new document
      *
      * @param string $tableName The name of the table into which the document should be inserted
-     * @param array|object $document The document to be inserted
+     * @param mixed[]|object $document The document to be inserted
      * @throws DocumentException If any is encountered
      */
     public static function insert(string $tableName, array|object $document): void
     {
         $doInsert = fn() => Custom::nonQuery(Query::insert($tableName), Parameters::json(':data', $document));
 
-        if (Configuration::$autoId == AutoId::None) {
+        if (Configuration::$autoId === AutoId::None) {
             $doInsert();
             return;
         }
@@ -41,7 +47,7 @@ class Document
      * Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
      *
      * @param string $tableName The name of the table to which the document should be saved
-     * @param array|object $document The document to be saved
+     * @param mixed[]|object $document The document to be saved
      * @throws DocumentException If any is encountered
      */
     public static function save(string $tableName, array|object $document): void
@@ -54,7 +60,7 @@ class Document
      *
      * @param string $tableName The table in which the document should be updated
      * @param mixed $docId The ID of the document to be updated
-     * @param array|object $document The document to be updated
+     * @param mixed[]|object $document The document to be updated
      * @throws DocumentException If any is encountered
      */
     public static function update(string $tableName, mixed $docId, array|object $document): void

src/DocumentException.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 

src/DocumentIndex.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 

src/DocumentList.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -15,8 +21,11 @@ use PDOStatement;
  */
 class DocumentList
 {
-    /** @var TDoc|null $_first The first item from the results  */
-    private mixed $_first = null;
+    /** @var TDoc|null $first The first item from the results  */
+    private mixed $first = null;
+
+    /** @var bool $isConsumed This is set to true once the generator has been exhausted */
+    private bool $isConsumed = false;
 
     /**
      * Constructor
@@ -26,51 +35,91 @@ class DocumentList
      */
     private function __construct(private ?PDOStatement &$result, private readonly Mapper $mapper)
     {
-        if ($row = $this->result->fetch(PDO::FETCH_ASSOC)) {
-            $this->_first = $this->mapper->map($row);
-        } else {
+        if (!is_null($this->result)) {
+            if ($row = $this->result->fetch(PDO::FETCH_ASSOC)) {
+                $this->first = $this->mapper->map($row);
+            } else {
+                $this->result = null;
+            }
+        }
+    }
+
+    /** @var bool True if there are items still to be retrieved from the list, false if not */
+    public bool $hasItems {
+        get => !is_null($this->result);
+    }
+
+    /**
+     * @var Generator<TDoc> The items from the document list
+     * @throws DocumentException If this is called once the generator has been consumed
+     */
+    public Generator $items {
+        get {
+            if (!$this->result) {
+                if ($this->isConsumed) {
+                    throw new DocumentException('Cannot call items() multiple times');
+                }
+                $this->isConsumed = true;
+                return;
+            }
+            if (!$this->first) {
+                $this->isConsumed = true;
+                $this->result = null;
+                return;
+            }
+            yield $this->first;
+            while ($row = $this->result->fetch(PDO::FETCH_ASSOC)) {
+                yield $this->mapper->map($row);
+            }
+            $this->isConsumed = true;
             $this->result = null;
         }
     }
 
     /**
-     * Construct a new document list
+     * Map items by consuming the generator
      *
-     * @param string $query The query to run to retrieve results
-     * @param array $parameters An associative array of parameters for the query
-     * @param Mapper<TDoc> $mapper A mapper to deserialize JSON documents
-     * @return static The document list instance
-     * @throws DocumentException If any is encountered
+     * @template U The type to which each item should be mapped
+     * @param callable(TDoc): U $map The mapping function
+     * @return Generator<U> The result of the mapping function
+     * @throws DocumentException If this is called once the generator has been consumed
      */
-    public static function create(string $query, array $parameters, Mapper $mapper): static
+    public function map(callable $map): Generator
     {
-        $stmt = &Custom::runQuery($query, $parameters);
-        return new static($stmt, $mapper);
-    }
-
-    /**
-     * The items from the query result
-     *
-     * @return Generator<TDoc> The items from the document list
-     */
-    public function items(): Generator
-    {
-        if (!$this->result) return;
-        yield $this->_first;
-        while ($row = $this->result->fetch(PDO::FETCH_ASSOC)) {
-            yield $this->mapper->map($row);
+        foreach ($this->items as $item) {
+            yield $map($item);
         }
-        $this->result = null;
     }
 
     /**
-     * Does this list have items remaining?
+     * Iterate the generator, running the given function for each item
      *
-     * @return bool True if there are items still to be retrieved from the list, false if not
+     * @param callable(TDoc): void $f The function to run for each item
+     * @throws DocumentException If this is called once the generator has been consumed
      */
-    public function hasItems(): bool
+    public function iter(callable $f): void
     {
-        return !is_null($this->result);
+        foreach ($this->items as $item) {
+            $f($item);
+        }
+    }
+
+    /**
+     * Iterate the generator, extracting key/value pairs returned as an associative array
+     *
+     * @template TValue The type for the mapped value
+     * @param callable(TDoc): (int|string) $keyFunc The function to extract a key from the document
+     * @param callable(TDoc): TValue $valueFunc The function to extract a value from the document
+     * @return TValue[] An associative array of values, keyed by the extracted keys
+     * @throws DocumentException If this is called once the generator has been consumed
+     */
+    public function mapToArray(callable $keyFunc, callable $valueFunc): array
+    {
+        $results = [];
+        foreach ($this->items as $item) {
+            $results[$keyFunc($item)] = $valueFunc($item);
+        }
+        return $results;
     }
 
     /**
@@ -80,4 +129,19 @@ class DocumentList
     {
         if (!is_null($this->result)) $this->result = null;
     }
+
+    /**
+     * Construct a new document list
+     *
+     * @param string $query The query to run to retrieve results
+     * @param array<string, mixed> $parameters An associative array of parameters for the query
+     * @param Mapper<TDoc> $mapper A mapper to deserialize JSON documents
+     * @return self<TDoc> The document list instance
+     * @throws DocumentException If any is encountered
+     */
+    public static function create(string $query, array $parameters, Mapper $mapper): self
+    {
+        $stmt = &Custom::runQuery($query, $parameters);
+        return new self($stmt, $mapper);
+    }
 }

src/Exists.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -33,16 +39,16 @@ class Exists
      */
     public static function byFields(string $tableName, array $fields, ?FieldMatch $match = null): bool
     {
-        $namedFields = Parameters::nameFields($fields);
-        return Custom::scalar(Query\Exists::byFields($tableName, $namedFields, $match),
-            Parameters::addFields($namedFields, []), new ExistsMapper());
+        Parameters::nameFields($fields);
+        return Custom::scalar(Query\Exists::byFields($tableName, $fields, $match), Parameters::addFields($fields, []),
+            new ExistsMapper());
     }
 
     /**
      * Determine if documents exist by a JSON containment query (`@>`; PostgreSQL only)
      *
      * @param string $tableName The name of the table in which document existence should be determined
-     * @param array|object $criteria The criteria for the JSON containment query
+     * @param mixed[]|object $criteria The criteria for the JSON containment query
      * @return bool True if any documents match the JSON containment query, false if not
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */

src/Field.php

@@ -1,7 +1,15 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
+use Exception;
+
 /**
  * Criteria for a field WHERE clause
  */
@@ -19,59 +27,110 @@ class Field
      * @param string $paramName The name of the parameter to which this should be bound
      * @param string $qualifier A table qualifier for the `data` column
      */
-    public function __construct(public string $fieldName = '', public Op $op = Op::EQ, public mixed $value = '',
+    public function __construct(public string $fieldName = '', public Op $op = Op::Equal, public mixed $value = '',
                                 public string $paramName = '', public string $qualifier = '') { }
 
     /**
      * Append the parameter name and value to the given associative array
      *
-     * @param array $existing The existing parameters
-     * @return array The given parameter array with this field's name and value appended
+     * @param array<string, mixed> $existing The existing parameters
+     * @return array<string, mixed> The given parameter array with this field's name and value(s) appended
      */
     public function appendParameter(array $existing): array
     {
         switch ($this->op) {
-            case Op::EX:
-            case Op::NEX:
+            case Op::Exists:
+            case Op::NotExists:
                 break;
-            case Op::BT:
+            case Op::Between:
                 $existing["{$this->paramName}min"] = $this->value[0];
                 $existing["{$this->paramName}max"] = $this->value[1];
                 break;
+            case Op::In:
+                for ($idx = 0; $idx < count($this->value); $idx++) {
+                    $existing["{$this->paramName}_$idx"] = $this->value[$idx];
+                }
+                break;
+            case Op::InArray:
+                $mkString = Configuration::mode("Append parameters for InArray condition") === Mode::PgSQL;
+                $values   = $this->value['values'];
+                for ($idx = 0; $idx < count($values); $idx++) {
+                    $existing["{$this->paramName}_$idx"] = $mkString ? "$values[$idx]" : $values[$idx];
+                }
+                break;
             default:
                 $existing[$this->paramName] = $this->value;
         }
         return $existing;
     }
 
+    /**
+     * Derive the path for this field
+     *
+     * @param bool $asJSON Whether the field should be treated as JSON in the query (optional, default false)
+     * @return string The path for this field
+     * @throws Exception If the database mode has not been set
+     */
+    public function path(bool $asJSON = false): string
+    {
+        $extra = $asJSON ? '' : '>';
+        if (str_contains($this->fieldName, '.')) {
+            $mode = Configuration::mode('determine field path');
+            if ($mode === Mode::PgSQL) {
+                return "data#>$extra'{" . implode(',', explode('.', $this->fieldName)) . "}'";
+            }
+            if ($mode === Mode::SQLite) {
+                $parts = explode('.', $this->fieldName);
+                $last  = array_pop($parts);
+                return "data->'" . implode("'->'", $parts) . "'->$extra'$last'";
+            }
+        }
+        return "data->$extra'$this->fieldName'";
+    }
+
     /**
      * Get the WHERE clause fragment for this parameter
      *
      * @return string The WHERE clause fragment for this parameter
-     * @throws DocumentException If the database mode has not been set
+     * @throws Exception|DocumentException If the database mode has not been set
      */
     public function toWhere(): string
     {
-        $fieldName = ($this->qualifier == '' ? '' : "$this->qualifier.") . 'data' . match (true) {
-            !str_contains($this->fieldName, '.') => "->>'$this->fieldName'",
-            Configuration::$mode == Mode::PgSQL  => "#>>'{" . implode(',', explode('.', $this->fieldName)) . "}'",
-            Configuration::$mode == Mode::SQLite => "->>'" . implode("'->>'", explode('.', $this->fieldName)) . "'",
-            default => throw new DocumentException('Database mode not set; cannot make field WHERE clause')
-        };
-        $fieldPath = match (Configuration::$mode) {
+        $mode        = Configuration::mode('make field WHERE clause');
+        $fieldName   = (empty($this->qualifier) ? '' : "$this->qualifier.") . $this->path($this->op === Op::InArray);
+        $fieldPath   = match ($mode) {
             Mode::PgSQL => match (true) {
-                $this->op == Op::BT      => is_numeric($this->value[0]) ? "($fieldName)::numeric" : $fieldName,
-                is_numeric($this->value) => "($fieldName)::numeric",
-                default                  => $fieldName
+                $this->op === Op::Between,
+                $this->op === Op::In      => is_numeric($this->value[0]) ? "($fieldName)::numeric" : $fieldName,
+                is_numeric($this->value)  => "($fieldName)::numeric",
+                default                   => $fieldName,
             },
-            default => $fieldName
+            default => $fieldName,
         };
         $criteria = match ($this->op) {
-            Op::EX, Op::NEX => '',
-            Op::BT          => " {$this->paramName}min AND {$this->paramName}max",
-            default         => " $this->paramName"
+            Op::Exists,
+            Op::NotExists => '',
+            Op::Between   => " {$this->paramName}min AND {$this->paramName}max",
+            Op::In        => ' (' . $this->inParameterNames() . ')',
+            Op::InArray   => $mode === Mode::PgSQL ? ' ARRAY[' . $this->inParameterNames() . ']' : '',
+            default       => " $this->paramName",
         };
-        return $fieldPath . ' ' . $this->op->toString() . $criteria;
+        return $mode === Mode::SQLite && $this->op === Op::InArray
+            ? "EXISTS (SELECT 1 FROM json_each({$this->value['table']}.data, '\$.$this->fieldName') WHERE value IN ("
+                    . $this->inParameterNames() . '))'
+            : $fieldPath . ' ' . $this->op->toSQL() . $criteria;
+    }
+
+    /**
+     * Create parameter names for an IN clause
+     *
+     * @return string A comma-delimited string of parameter names
+     */
+    private function inParameterNames(): string
+    {
+        $values = $this->op === Op::In ? $this->value : $this->value['values'];
+        return implode(', ',
+            array_map(fn($value, $key) => "{$this->paramName}_$key", $values, range(0, count($values) - 1)));
     }
 
     /**
@@ -80,11 +139,24 @@ class Field
      * @param string $fieldName The name of the field against which the value will be compared
      * @param mixed $value The value for which equality will be checked
      * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
-     * @return static The field with the requested criterion
+     * @return self The field with the requested criterion
      */
-    public static function EQ(string $fieldName, mixed $value, string $paramName = ''): static
+    public static function equal(string $fieldName, mixed $value, string $paramName = ''): self
     {
-        return new static($fieldName, Op::EQ, $value, $paramName);
+        return new self($fieldName, Op::Equal, $value, $paramName);
+    }
+
+    /**
+     * Create an equals (=) field criterion _(alias for `Field.equal`)_
+     *
+     * @param string $fieldName The name of the field against which the value will be compared
+     * @param mixed $value The value for which equality will be checked
+     * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
+     * @return self The field with the requested criterion
+     */
+    public static function EQ(string $fieldName, mixed $value, string $paramName = ''): self
+    {
+        return self::equal($fieldName, $value, $paramName);
     }
 
     /**
@@ -93,11 +165,24 @@ class Field
      * @param string $fieldName The name of the field against which the value will be compared
      * @param mixed $value The value for the greater than comparison
      * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
-     * @return static The field with the requested criterion
+     * @return self The field with the requested criterion
      */
-    public static function GT(string $fieldName, mixed $value, string $paramName = ''): static
+    public static function greater(string $fieldName, mixed $value, string $paramName = ''): self
     {
-        return new static($fieldName, Op::GT, $value, $paramName);
+        return new self($fieldName, Op::Greater, $value, $paramName);
+    }
+
+    /**
+     * Create a greater than (>) field criterion _(alias for `Field.greater`)_
+     *
+     * @param string $fieldName The name of the field against which the value will be compared
+     * @param mixed $value The value for the greater than comparison
+     * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
+     * @return self The field with the requested criterion
+     */
+    public static function GT(string $fieldName, mixed $value, string $paramName = ''): self
+    {
+        return self::greater($fieldName, $value, $paramName);
     }
 
     /**
@@ -106,11 +191,24 @@ class Field
      * @param string $fieldName The name of the field against which the value will be compared
      * @param mixed $value The value for the greater than or equal to comparison
      * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
-     * @return static The field with the requested criterion
+     * @return self The field with the requested criterion
      */
-    public static function GE(string $fieldName, mixed $value, string $paramName = ''): static
+    public static function greaterOrEqual(string $fieldName, mixed $value, string $paramName = ''): self
     {
-        return new static($fieldName, Op::GE, $value, $paramName);
+        return new self($fieldName, Op::GreaterOrEqual, $value, $paramName);
+    }
+
+    /**
+     * Create a greater than or equal to (>=) field criterion _(alias for `Field.greaterOrEqual`)_
+     *
+     * @param string $fieldName The name of the field against which the value will be compared
+     * @param mixed $value The value for the greater than or equal to comparison
+     * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
+     * @return self The field with the requested criterion
+     */
+    public static function GE(string $fieldName, mixed $value, string $paramName = ''): self
+    {
+        return self::greaterOrEqual($fieldName, $value, $paramName);
     }
 
     /**
@@ -119,11 +217,24 @@ class Field
      * @param string $fieldName The name of the field against which the value will be compared
      * @param mixed $value The value for the less than comparison
      * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
-     * @return static The field with the requested criterion
+     * @return self The field with the requested criterion
      */
-    public static function LT(string $fieldName, mixed $value, string $paramName = ''): static
+    public static function less(string $fieldName, mixed $value, string $paramName = ''): self
     {
-        return new static($fieldName, Op::LT, $value, $paramName);
+        return new self($fieldName, Op::Less, $value, $paramName);
+    }
+
+    /**
+     * Create a less than (<) field criterion _(alias for `Field.less`)_
+     *
+     * @param string $fieldName The name of the field against which the value will be compared
+     * @param mixed $value The value for the less than comparison
+     * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
+     * @return self The field with the requested criterion
+     */
+    public static function LT(string $fieldName, mixed $value, string $paramName = ''): self
+    {
+        return self::less($fieldName, $value, $paramName);
     }
 
     /**
@@ -132,11 +243,24 @@ class Field
      * @param string $fieldName The name of the field against which the value will be compared
      * @param mixed $value The value for the less than or equal to comparison
      * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
-     * @return static The field with the requested criterion
+     * @return self The field with the requested criterion
      */
-    public static function LE(string $fieldName, mixed $value, string $paramName = ''): static
+    public static function lessOrEqual(string $fieldName, mixed $value, string $paramName = ''): self
     {
-        return new static($fieldName, Op::LE, $value, $paramName);
+        return new self($fieldName, Op::LessOrEqual, $value, $paramName);
+    }
+
+    /**
+     * Create a less than or equal to (<=) field criterion _(alias for `Field.lessOrEqual`)_
+     *
+     * @param string $fieldName The name of the field against which the value will be compared
+     * @param mixed $value The value for the less than or equal to comparison
+     * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
+     * @return self The field with the requested criterion
+     */
+    public static function LE(string $fieldName, mixed $value, string $paramName = ''): self
+    {
+        return self::lessOrEqual($fieldName, $value, $paramName);
     }
 
     /**
@@ -145,11 +269,24 @@ class Field
      * @param string $fieldName The name of the field against which the value will be compared
      * @param mixed $value The value for the not equals comparison
      * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
-     * @return static The field with the requested criterion
+     * @return self The field with the requested criterion
      */
-    public static function NE(string $fieldName, mixed $value, string $paramName = ''): static
+    public static function notEqual(string $fieldName, mixed $value, string $paramName = ''): self
     {
-        return new static($fieldName, Op::NE, $value, $paramName);
+        return new self($fieldName, Op::NotEqual, $value, $paramName);
+    }
+
+    /**
+     * Create a not equals (<>) field criterion _(alias for `Field.notEqual`)_
+     *
+     * @param string $fieldName The name of the field against which the value will be compared
+     * @param mixed $value The value for the not equals comparison
+     * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
+     * @return self The field with the requested criterion
+     */
+    public static function NE(string $fieldName, mixed $value, string $paramName = ''): self
+    {
+        return self::notEqual($fieldName, $value, $paramName);
     }
 
     /**
@@ -159,32 +296,109 @@ class Field
      * @param mixed $minValue The lower value for range
      * @param mixed $maxValue The upper value for the range
      * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
-     * @return static The field with the requested criterion
+     * @return self The field with the requested criterion
      */
-    public static function BT(string $fieldName, mixed $minValue, mixed $maxValue, string $paramName = ''): static
+    public static function between(string $fieldName, mixed $minValue, mixed $maxValue, string $paramName = ''): self
     {
-        return new static($fieldName, Op::BT, [$minValue, $maxValue], $paramName);
+        return new self($fieldName, Op::Between, [$minValue, $maxValue], $paramName);
+    }
+
+    /**
+     * Create a BETWEEN field criterion _(alias for `Field.between`)_
+     *
+     * @param string $fieldName The name of the field against which the value will be compared
+     * @param mixed $minValue The lower value for range
+     * @param mixed $maxValue The upper value for the range
+     * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
+     * @return self The field with the requested criterion
+     */
+    public static function BT(string $fieldName, mixed $minValue, mixed $maxValue, string $paramName = ''): self
+    {
+        return self::between($fieldName, $minValue, $maxValue, $paramName);
+    }
+
+    /**
+     * Create an IN field criterion
+     *
+     * @param string $fieldName The name of the field against which the values will be compared
+     * @param mixed[] $values The potential matching values for the field
+     * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
+     * @return self The field with the requested criterion
+     */
+    public static function in(string $fieldName, array $values, string $paramName = ''): self
+    {
+        return new self($fieldName, Op::In, $values, $paramName);
+    }
+
+    /**
+     * Create an IN ARRAY field criterion
+     *
+     * @param string $fieldName The name of the field against which the values will be compared
+     * @param string $tableName The table name where this field is located
+     * @param mixed[] $values The potential matching values for the field
+     * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
+     * @return self The field with the requested criterion
+     */
+    public static function inArray(string $fieldName, string $tableName, array $values, string $paramName = ''): self
+    {
+        return new self($fieldName, Op::InArray, ['table' => $tableName, 'values' => $values], $paramName);
     }
 
     /**
      * Create an exists (IS NOT NULL) field criterion
      *
      * @param string $fieldName The name of the field for which existence will be checked
-     * @return static The field with the requested criterion
+     * @return self The field with the requested criterion
      */
-    public static function EX(string $fieldName): static
+    public static function exists(string $fieldName): self
     {
-        return new static($fieldName, Op::EX, '', '');
+        return new self($fieldName, Op::Exists, '', '');
+    }
+
+    /**
+     * Create an exists (IS NOT NULL) field criterion _(alias for `Field.exists`)_
+     *
+     * @param string $fieldName The name of the field for which existence will be checked
+     * @return self The field with the requested criterion
+     */
+    public static function EX(string $fieldName): self
+    {
+        return self::exists($fieldName);
     }
 
     /**
      * Create a not exists (IS NULL) field criterion
      *
      * @param string $fieldName The name of the field for which non-existence will be checked
-     * @return static The field with the requested criterion
+     * @return self The field with the requested criterion
      */
-    public static function NEX(string $fieldName): static
+    public static function notExists(string $fieldName): self
     {
-        return new static($fieldName, Op::NEX, '', '');
+        return new self($fieldName, Op::NotExists, '', '');
+    }
+
+    /**
+     * Create a not exists (IS NULL) field criterion _(alias for `Field.notExists`)_
+     *
+     * @param string $fieldName The name of the field for which non-existence will be checked
+     * @return self The field with the requested criterion
+     */
+    public static function NEX(string $fieldName): self
+    {
+        return self::notExists($fieldName);
+    }
+
+    /**
+     * Create a named fields (used for creating fields for ORDER BY clauses)
+     *
+     * Prepend the field name with 'n:' to treat the field as a number; prepend the field name with 'i:' to perform
+     * a case-insensitive ordering.
+     *
+     * @param string $name The name of the field, plus any direction for the ordering
+     * @return self
+     */
+    public static function named(string $name): self
+    {
+        return new self($name, Op::Equal, '', '');
     }
 }

src/FieldMatch.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -18,11 +24,11 @@ enum FieldMatch
      *
      * @return string The SQL keyword for this enumeration value
      */
-    public function toString(): string
+    public function toSQL(): string
     {
         return match ($this) {
             FieldMatch::All => 'AND',
-            FieldMatch::Any => 'OR'
+            FieldMatch::Any => 'OR',
         };
     }
 }

src/Find.php

@@ -1,7 +1,14 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
+use BitBadger\InspiredByFSharp\Option;
 use BitBadger\PDODocument\Mapper\DocumentMapper;
 
 /**
@@ -15,12 +22,14 @@ class Find
      * @template TDoc The type of document to be retrieved
      * @param string $tableName The table from which documents should be retrieved
      * @param class-string<TDoc> $className The name of the class to be retrieved
+     * @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
      * @return DocumentList<TDoc> A list of all documents from the table
      * @throws DocumentException If any is encountered
      */
-    public static function all(string $tableName, string $className): DocumentList
+    public static function all(string $tableName, string $className, array $orderBy = []): DocumentList
     {
-        return Custom::list(Query::selectFromTable($tableName), [], new DocumentMapper($className));
+        return Custom::list(Query::selectFromTable($tableName) . Query::orderBy($orderBy), [],
+            new DocumentMapper($className));
     }
 
     /**
@@ -30,10 +39,10 @@ class Find
      * @param string $tableName The table from which the document should be retrieved
      * @param mixed $docId The ID of the document to retrieve
      * @param class-string<TDoc> $className The name of the class to be retrieved
-     * @return false|TDoc The document if it exists, false if not
+     * @return Option<TDoc> A `Some` instance if the document is found, `None` otherwise
      * @throws DocumentException If any is encountered
      */
-    public static function byId(string $tableName, mixed $docId, string $className): mixed
+    public static function byId(string $tableName, mixed $docId, string $className): Option
     {
         return Custom::single(Query\Find::byId($tableName, $docId), Parameters::id($docId),
             new DocumentMapper($className));
@@ -44,18 +53,19 @@ class Find
      *
      * @template TDoc The type of document to be retrieved
      * @param string $tableName The table from which documents should be retrieved
-     * @param array|Field[] $fields The field comparison to match
+     * @param Field[] $fields The field comparison to match
      * @param class-string<TDoc> $className The name of the class to be retrieved
      * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
+     * @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
      * @return DocumentList<TDoc> A list of documents matching the given field comparison
      * @throws DocumentException If any is encountered
      */
     public static function byFields(string $tableName, array $fields, string $className,
-                                    ?FieldMatch $match = null): DocumentList
+                                    ?FieldMatch $match = null, array $orderBy = []): DocumentList
     {
-        $namedFields = Parameters::nameFields($fields);
-        return Custom::list(Query\Find::byFields($tableName, $namedFields, $match),
-            Parameters::addFields($namedFields, []), new DocumentMapper($className));
+        Parameters::nameFields($fields);
+        return Custom::list(Query\Find::byFields($tableName, $fields, $match) . Query::orderBy($orderBy),
+            Parameters::addFields($fields, []), new DocumentMapper($className));
     }
 
     /**
@@ -63,15 +73,17 @@ class Find
      *
      * @template TDoc The type of document to be retrieved
      * @param string $tableName The name of the table from which documents should be retrieved
-     * @param array|object $criteria The criteria for the JSON containment query
+     * @param mixed[]|object $criteria The criteria for the JSON containment query
      * @param class-string<TDoc> $className The name of the class to be retrieved
+     * @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
      * @return DocumentList<TDoc> A list of documents matching the JSON containment query
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */
-    public static function byContains(string $tableName, array|object $criteria, string $className): DocumentList
+    public static function byContains(string $tableName, array|object $criteria, string $className,
+                                      array $orderBy = []): DocumentList
     {
-        return Custom::list(Query\Find::byContains($tableName), Parameters::json(':criteria', $criteria),
-            new DocumentMapper($className));
+        return Custom::list(Query\Find::byContains($tableName) . Query::orderBy($orderBy),
+            Parameters::json(':criteria', $criteria), new DocumentMapper($className));
     }
 
     /**
@@ -81,12 +93,15 @@ class Find
      * @param string $tableName The name of the table from which documents should be retrieved
      * @param string $path The JSON Path match string
      * @param class-string<TDoc> $className The name of the class to be retrieved
+     * @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
      * @return DocumentList<TDoc> A list of documents matching the JSON Path
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */
-    public static function byJsonPath(string $tableName, string $path, string $className): DocumentList
+    public static function byJsonPath(string $tableName, string $path, string $className,
+                                      array $orderBy = []): DocumentList
     {
-        return Custom::list(Query\Find::byJsonPath($tableName), [':path' => $path], new DocumentMapper($className));
+        return Custom::list(Query\Find::byJsonPath($tableName) . Query::orderBy($orderBy), [':path' => $path],
+            new DocumentMapper($className));
     }
 
     /**
@@ -94,18 +109,19 @@ class Find
      *
      * @template TDoc The type of document to be retrieved
      * @param string $tableName The table from which the document should be retrieved
-     * @param array|Field[] $fields The field comparison to match
+     * @param Field[] $fields The field comparison to match
      * @param class-string<TDoc> $className The name of the class to be retrieved
      * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
-     * @return false|TDoc The first document if any matches are found, false otherwise
+     * @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
+     * @return Option<TDoc> A `Some` instance with the first document if any matches are found, `None` otherwise
      * @throws DocumentException If any is encountered
      */
     public static function firstByFields(string $tableName, array $fields, string $className,
-                                         ?FieldMatch $match = null): mixed
+                                         ?FieldMatch $match = null, array $orderBy = []): Option
     {
-        $namedFields = Parameters::nameFields($fields);
-        return Custom::single(Query\Find::byFields($tableName, $namedFields, $match),
-            Parameters::addFields($namedFields, []), new DocumentMapper($className));
+        Parameters::nameFields($fields);
+        return Custom::single(Query\Find::byFields($tableName, $fields, $match) . Query::orderBy($orderBy),
+            Parameters::addFields($fields, []), new DocumentMapper($className));
     }
 
     /**
@@ -113,15 +129,17 @@ class Find
      *
      * @template TDoc The type of document to be retrieved
      * @param string $tableName The name of the table from which documents should be retrieved
-     * @param array|object $criteria The criteria for the JSON containment query
+     * @param mixed[]|object $criteria The criteria for the JSON containment query
      * @param class-string<TDoc> $className The name of the class to be retrieved
-     * @return false|TDoc The first document matching the JSON containment query if any is found, false otherwise
+     * @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
+     * @return Option<TDoc> A `Some` instance with the first document if any matches are found, `None` otherwise
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */
-    public static function firstByContains(string $tableName, array|object $criteria, string $className): mixed
+    public static function firstByContains(string $tableName, array|object $criteria, string $className,
+                                           array $orderBy = []): Option
     {
-        return Custom::single(Query\Find::byContains($tableName), Parameters::json(':criteria', $criteria),
-            new DocumentMapper($className));
+        return Custom::single(Query\Find::byContains($tableName) . Query::orderBy($orderBy),
+            Parameters::json(':criteria', $criteria), new DocumentMapper($className));
     }
 
     /**
@@ -131,11 +149,14 @@ class Find
      * @param string $tableName The name of the table from which documents should be retrieved
      * @param string $path The JSON Path match string
      * @param class-string<TDoc> $className The name of the class to be retrieved
-     * @return false|TDoc The first document matching the JSON Path if any is found, false otherwise
+     * @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
+     * @return Option<TDoc> A `Some` instance with the first document if any matches are found, `None` otherwise
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */
-    public static function firstByJsonPath(string $tableName, string $path, string $className): mixed
+    public static function firstByJsonPath(string $tableName, string $path, string $className,
+                                           array $orderBy = []): Option
     {
-        return Custom::single(Query\Find::byJsonPath($tableName), [':path' => $path], new DocumentMapper($className));
+        return Custom::single(Query\Find::byJsonPath($tableName) . Query::orderBy($orderBy), [':path' => $path],
+            new DocumentMapper($className));
     }
 }

src/Mapper/ArrayMapper.php

@@ -1,14 +1,23 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Mapper;
 
 /**
  * A mapper that returns the associative array from the database
+ *
+ * @implements Mapper<array<string|int, mixed>>
  */
 class ArrayMapper implements Mapper
 {
     /**
      * @inheritDoc
+     * @return array<string|int, mixed> The array given as the parameter
      */
     public function map(array $result): array
     {

src/Mapper/CountMapper.php

@@ -1,15 +1,21 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Mapper;
 
 /**
  * A mapper that returns the integer value of the first item in the results
+ *
+ * @implements Mapper<int>
  */
 class CountMapper implements Mapper
 {
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     public function map(array $result): int
     {
         return (int) $result[0];

src/Mapper/DocumentMapper.php

@@ -1,10 +1,16 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Mapper;
 
 use BitBadger\PDODocument\DocumentException;
+use Exception;
 use JsonMapper;
-use JsonMapper_Exception;
 
 /**
  * Map domain class instances from JSON documents
@@ -20,24 +26,27 @@ class DocumentMapper implements Mapper
      * @param class-string<TDoc> $className The type of class to be returned by this mapping
      * @param string $fieldName The name of the field (optional; defaults to `data`)
      */
-    public function __construct(public string $className, public string $fieldName = 'data') { }
+    public function __construct(public string $className, public string $fieldName = 'data') {}
 
     /**
      * Map a result to a domain class instance
      *
-     * @param array $result An associative array representing a single database result
+     * @param array<string|int, mixed> $result An associative array representing a single database result
      * @return TDoc The document, deserialized from its JSON representation
      * @throws DocumentException If the JSON cannot be deserialized
      */
     public function map(array $result): mixed
     {
         try {
+            if (method_exists($this->className, 'fromJsonString')) {
+                return $this->className::fromJsonString($result[$this->fieldName]);
+            }
             $json = json_decode($result[$this->fieldName]);
             if (is_null($json)) {
                 throw new DocumentException("Could not map document for $this->className: " . json_last_error_msg());
             }
             return (new JsonMapper())->map($json, $this->className);
-        } catch (JsonMapper_Exception $ex) {
+        } catch (Exception $ex) {
             throw new DocumentException("Could not map document for $this->className", previous: $ex);
         }
     }

src/Mapper/ExistsMapper.php

@@ -1,24 +1,32 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Mapper;
 
-use BitBadger\PDODocument\{Configuration, DocumentException, Mode};
+use BitBadger\PDODocument\{Configuration, Mode};
+use Exception;
 
 /**
  * Map an EXISTS result to a boolean value
+ *
+ * @implements Mapper<bool>
  */
 class ExistsMapper implements Mapper
 {
     /**
      * @inheritDoc
-     * @throws DocumentException If the database mode has not been set
+     * @throws Exception If the database mode has not been set
      */
     public function map(array $result): bool
     {
-        return match (Configuration::$mode) {
+        return match (Configuration::mode('map existence result')) {
             Mode::PgSQL  => (bool)$result[0],
             Mode::SQLite => (int)$result[0] > 0,
-            default      => throw new DocumentException('Database mode not set; cannot map existence result'),
         };
     }
 }

src/Mapper/Mapper.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Mapper;
 
@@ -12,7 +18,7 @@ interface Mapper
     /**
      * Map a result to the specified type
      *
-     * @param array $result An associative array representing a single database result
+     * @param array<string|int, mixed> $result An associative array representing a single database result
      * @return T The item mapped from the given result
      */
     public function map(array $result): mixed;

src/Mapper/StringMapper.php

@@ -1,9 +1,15 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Mapper;
 
 /**
- * Map a string result from the
+ * Map a string result from the named field
  *
  * @implements Mapper<string>
  */
@@ -24,7 +30,7 @@ class StringMapper implements Mapper
         return match (false) {
             key_exists($this->fieldName, $result) => null,
             is_string($result[$this->fieldName])  => "{$result[$this->fieldName]}",
-            default                               => $result[$this->fieldName]
+            default                               => $result[$this->fieldName],
         };
     }
 }

src/Mode.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -12,4 +18,19 @@ enum Mode
 
     /** Storing documents in a SQLite database */
     case SQLite;
+
+    /**
+     * Derive the mode from the Data Source Name (DSN)
+     *
+     * @return Mode The database mode based on the DSN
+     * @throws DocumentException If the DSN does not start with `pgsql:` or `sqlite:`
+     */
+    public static function deriveFromDSN(string $dsn): Mode
+    {
+        return match (true) {
+            str_starts_with($dsn, 'pgsql:')  => Mode::PgSQL,
+            str_starts_with($dsn, 'sqlite:') => Mode::SQLite,
+            default => throw new DocumentException('This library currently supports PostgreSQL and SQLite'),
+        };
+    }
 }

src/Op.php

@@ -1,48 +1,60 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
 /**
- * The types of logical operations allowed for JSON fields
+ * The types of comparison operators allowed for JSON fields
  */
 enum Op
 {
     /** Equals (=) */
-    case EQ;
+    case Equal;
     /** Greater Than (>) */
-    case GT;
+    case Greater;
     /** Greater Than or Equal To (>=) */
-    case GE;
+    case GreaterOrEqual;
     /** Less Than (<) */
-    case LT;
+    case Less;
     /** Less Than or Equal To (<=) */
-    case LE;
+    case LessOrEqual;
     /** Not Equal to (<>) */
-    case NE;
+    case NotEqual;
     /** Between (BETWEEN) */
-    case BT;
+    case Between;
+    /** In (IN) */
+    case In;
+    /** In Array (PostgreSQL - ?|, SQLite - EXISTS / json_each / IN) */
+    case InArray;
     /** Exists (IS NOT NULL) */
-    case EX;
+    case Exists;
     /** Does Not Exist (IS NULL) */
-    case NEX;
+    case NotExists;
 
     /**
-     * Get the string representation of this operator
+     * Get the SQL representation of this operator
      *
      * @return string The operator to use in SQL statements
      */
-    public function toString(): string
+    public function toSQL(): string
     {
         return match ($this) {
-            Op::EQ  => "=",
-            Op::GT  => ">",
-            Op::GE  => ">=",
-            Op::LT  => "<",
-            Op::LE  => "<=",
-            Op::NE  => "<>",
-            Op::BT  => "BETWEEN",
-            Op::EX  => "IS NOT NULL",
-            Op::NEX => "IS NULL"
+            Op::Equal           => "=",
+            Op::Greater         => ">",
+            Op::GreaterOrEqual  => ">=",
+            Op::Less            => "<",
+            Op::LessOrEqual     => "<=",
+            Op::NotEqual        => "<>",
+            Op::Between         => "BETWEEN",
+            Op::In              => "IN",
+            Op::InArray         => "??|", // The actual operator is ?|, but needs to be escaped by doubling
+            Op::Exists          => "IS NOT NULL",
+            Op::NotExists       => "IS NULL",
         };
     }
 }

src/Parameters.php

@@ -1,7 +1,15 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
+use Exception;
+
 /**
  * Functions to create parameters for queries
  */
@@ -11,45 +19,61 @@ class Parameters
      * Create an ID parameter (name ":id", key will be treated as a string)
      *
      * @param mixed $key The key representing the ID of the document
-     * @return array|string[] An associative array with an "@id" parameter/value pair
+     * @return array<string, mixed> An associative array with an "@id" parameter/value pair
      */
     public static function id(mixed $key): array
     {
-        return [':id' => is_int($key) || is_string($key) ? $key : "$key"];
+        return [':id' => ((is_int($key) || is_string($key)) ? $key : "$key")];
     }
 
     /**
      * Create a parameter with a JSON value
      *
      * @param string $name The name of the JSON parameter
-     * @param object|array $document The value that should be passed as a JSON string
-     * @return array An associative array with the named parameter/value pair
+     * @param mixed[]|object $document The value that should be passed as a JSON string
+     * @return array<string, string> An associative array with the named parameter/value pair
      */
     public static function json(string $name, object|array $document): array
     {
-        return [$name => json_encode($document, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)];
+        $flags = JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES;
+
+        if (is_object($document)) {
+            return [
+                $name => method_exists($document, 'toJson') ? $document->toJson($flags) : json_encode($document, $flags)
+            ];
+        }
+
+        $key = array_key_first($document);
+        if (is_array($document[$key])) {
+            if (empty($document[$key])) return [$name => json_encode($document, $flags)];
+            if (method_exists($document[$key][array_key_first($document[$key])], 'toJson')) {
+                return [
+                    $name => sprintf('{%s:[%s]}', json_encode($key, $flags),
+                        implode(',', array_map(fn($it) => $it->toJson($flags), $document[$key])))
+                ];
+            }
+        }
+        return [$name => json_encode($document, $flags)];
     }
 
     /**
      * Fill in parameter names for any fields missing one
      *
-     * @param array|Field[] $fields The fields for the query
-     * @return array|Field[] The fields, all with non-blank parameter names
+     * @param Field[] $fields The fields for the query (entries with no names will be modified)
      */
-    public static function nameFields(array $fields): array
+    public static function nameFields(array &$fields): void
     {
-        for ($idx = 0; $idx < sizeof($fields); $idx++) {
-            if ($fields[$idx]->paramName == '') $fields[$idx]->paramName = ":field$idx";
-        }
-        return $fields;
+        array_walk($fields, function (Field $field, int $idx) {
+            if (empty($field->paramName)) $field->paramName =":field$idx";
+        });
     }
 
     /**
      * Add field parameters to the given set of parameters
      *
-     * @param array|Field[] $fields The fields being compared in the query
-     * @param array $parameters An associative array of parameters to which the fields should be added
-     * @return array An associative array of parameter names and values with the fields added
+     * @param Field[] $fields The fields being compared in the query
+     * @param array<string, mixed> $parameters An associative array of parameters to which the fields should be added
+     * @return array<string, mixed> An associative array of parameter names and values with the fields added
      */
     public static function addFields(array $fields, array $parameters): array
     {
@@ -60,22 +84,18 @@ class Parameters
      * Create JSON field name parameters for the given field names to the given parameter
      *
      * @param string $paramName The name of the parameter for the field names
-     * @param array|string[] $fieldNames The names of the fields for the parameter
-     * @return array An associative array of parameter/value pairs for the field names
-     * @throws DocumentException If the database mode has not been set
+     * @param string[] $fieldNames The names of the fields for the parameter
+     * @return array<string, string> An associative array of parameter/value pairs for the field names
+     * @throws Exception If the database mode has not been set
      */
     public static function fieldNames(string $paramName, array $fieldNames): array
     {
-        switch (Configuration::$mode) {
-            case Mode::PgSQL:
-                return [$paramName => "{" . implode(",", $fieldNames) . "}"];
-            case Mode::SQLite:
-                $it = [];
-                $idx = 0;
-                foreach ($fieldNames as $field) $it[$paramName . $idx++] = "$.$field";
-                return $it;
-            default:
-                throw new DocumentException('Database mode not set; cannot generate field name parameters');
-        }
+        $mode = Configuration::mode('generate field name parameters');
+        return match ($mode) {
+            Mode::PgSQL  => [$paramName => "{" . implode(",", $fieldNames) . "}"],
+            Mode::SQLite => array_combine(array_map(fn($idx) => $paramName . $idx,
+                                              empty($fieldNames) ? [] : range(0, sizeof($fieldNames) - 1)),
+                                          array_map(fn($field) => "$.$field", $fieldNames))
+        };
     }
 }

src/Patch.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -12,7 +18,7 @@ class Patch
      *
      * @param string $tableName The table in which the document should be patched
      * @param mixed $docId The ID of the document to be patched
-     * @param array|object $patch The object with which the document should be patched (will be JSON-encoded)
+     * @param mixed[]|object $patch The object with which the document should be patched (will be JSON-encoded)
      * @throws DocumentException If any is encountered (database mode must be set)
      */
     public static function byId(string $tableName, mixed $docId, array|object $patch): void
@@ -25,25 +31,25 @@ class Patch
      * Patch documents using a comparison on JSON fields
      *
      * @param string $tableName The table in which documents should be patched
-     * @param array|Field[] $fields The field comparison to match
-     * @param array|object $patch The object with which the documents should be patched (will be JSON-encoded)
+     * @param Field[] $fields The field comparison to match
+     * @param mixed[]|object $patch The object with which the documents should be patched (will be JSON-encoded)
      * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
      * @throws DocumentException If any is encountered
      */
     public static function byFields(string $tableName, array $fields, array|object $patch,
                                     ?FieldMatch $match = null): void
     {
-        $namedFields = Parameters::nameFields($fields);
-        Custom::nonQuery(Query\Patch::byFields($tableName, $namedFields, $match),
-            Parameters::addFields($namedFields, Parameters::json(':data', $patch)));
+        Parameters::nameFields($fields);
+        Custom::nonQuery(Query\Patch::byFields($tableName, $fields, $match),
+            Parameters::addFields($fields, Parameters::json(':data', $patch)));
     }
 
     /**
      * Patch documents using a JSON containment query (`@>`; PostgreSQL only)
      *
      * @param string $tableName The table in which documents should be patched
-     * @param array|object $criteria The JSON containment query values to match
-     * @param array|object $patch The object with which the documents should be patched (will be JSON-encoded)
+     * @param mixed[]|object $criteria The JSON containment query values to match
+     * @param mixed[]|object $patch The object with which the documents should be patched (will be JSON-encoded)
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */
     public static function byContains(string $tableName, array|object $criteria, array|object $patch): void
@@ -57,7 +63,7 @@ class Patch
      *
      * @param string $tableName The table in which documents should be patched
      * @param string $path The JSON Path match string
-     * @param array|object $patch The object with which the documents should be patched (will be JSON-encoded)
+     * @param mixed[]|object $patch The object with which the documents should be patched (will be JSON-encoded)
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */
     public static function byJsonPath(string $tableName, string $path, array|object $patch): void

src/Query.php

@@ -1,7 +1,14 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
+use Exception;
 use Random\RandomException;
 
 /**
@@ -30,8 +37,7 @@ class Query
      */
     public static function whereByFields(array $fields, ?FieldMatch $match = null): string
     {
-        return implode(' ' . ($match ?? FieldMatch::All)->toString() . ' ',
-            array_map(fn($it) => $it->toWhere(), $fields));
+        return implode(' ' . ($match ?? FieldMatch::All)->toSQL() . ' ', array_map(fn($it) => $it->toWhere(), $fields));
     }
 
     /**
@@ -45,7 +51,7 @@ class Query
      */
     public static function whereById(string $paramName = ':id', mixed $docId = null): string
     {
-        return self::whereByFields([Field::EQ(Configuration::$idField, $docId ?? '', $paramName)]);
+        return self::whereByFields([Field::equal(Configuration::$idField, $docId ?? '', $paramName)]);
     }
 
     /**
@@ -53,11 +59,11 @@ class Query
      *
      * @param string $paramName The name of the parameter (optional; defaults to `:criteria`)
      * @return string The WHERE clause fragment for a JSON containment query
-     * @throws DocumentException If the database mode is not PostgreSQL
+     * @throws Exception|DocumentException If the database mode is not PostgreSQL
      */
     public static function whereDataContains(string $paramName = ':criteria'): string
     {
-        if (Configuration::$mode <> Mode::PgSQL) {
+        if (Configuration::mode() <> Mode::PgSQL) {
             throw new DocumentException('JSON containment is only supported on PostgreSQL');
         }
         return "data @> $paramName";
@@ -68,11 +74,11 @@ class Query
      *
      * @param string $paramName The name of the parameter (optional; defaults to `:path`)
      * @return string The WHERE clause fragment for a JSON Path match query
-     * @throws DocumentException If the database mode is not PostgreSQL
+     * @throws Exception|DocumentException If the database mode is not PostgreSQL
      */
     public static function whereJsonPathMatches(string $paramName = ':path'): string
     {
-        if (Configuration::$mode <> Mode::PgSQL) {
+        if (Configuration::mode() <> Mode::PgSQL) {
             throw new DocumentException('JSON Path matching is only supported on PostgreSQL');
         }
         return "jsonb_path_exists(data, $paramName::jsonpath)";
@@ -84,19 +90,19 @@ class Query
      * @param string $tableName The name of the table into which the document will be inserted
      * @param AutoId|null $autoId The version of automatic ID query to generate (optional, defaults to None)
      * @return string The `INSERT` statement to insert a document
-     * @throws DocumentException If the database mode is not set
+     * @throws Exception|DocumentException If the database mode is not set
      */
     public static function insert(string $tableName, ?AutoId $autoId = null): string
     {
         try {
-            $id = Configuration::$idField;
-            $values = match (Configuration::$mode) {
+            $id     = Configuration::$idField;
+            $values = match (Configuration::mode('generate auto-ID INSERT statement')) {
                 Mode::SQLite => match ($autoId ?? AutoId::None) {
                     AutoId::None         => ':data',
                     AutoId::Number       => "json_set(:data, '$.$id', "
                                                 . "(SELECT coalesce(max(data->>'$id'), 0) + 1 FROM $tableName))",
                     AutoId::UUID         => "json_set(:data, '$.$id', '" . AutoId::generateUUID() . "')",
-                    AutoId::RandomString => "json_set(:data, '$.$id', '" . AutoId::generateRandom() ."')"
+                    AutoId::RandomString => "json_set(:data, '$.$id', '" . AutoId::generateRandom() ."')",
                 },
                 Mode::PgSQL => match ($autoId ?? AutoId::None) {
                     AutoId::None         => ':data',
@@ -105,9 +111,7 @@ class Query
                                                     . "FROM $tableName) || '}')::jsonb",
                     AutoId::UUID         => ":data::jsonb || '{\"$id\":\"" . AutoId::generateUUID() . "\"}'",
                     AutoId::RandomString => ":data::jsonb || '{\"$id\":\"" . AutoId::generateRandom() . "\"}'",
-                },
-                default =>
-                    throw new DocumentException('Database mode not set; cannot generate auto-ID INSERT statement'),
+                }
             };
             return "INSERT INTO $tableName VALUES ($values)";
         } catch (RandomException $ex) {
@@ -138,4 +142,54 @@ class Query
     {
         return "UPDATE $tableName SET data = :data WHERE " . self::whereById();
     }
+
+    /**
+     * Transform a field to an ORDER BY clause segment
+     *
+     * @param Field $field The field by which ordering should be implemented
+     * @return string The ORDER BY fragment for the given field
+     * @throws Exception If the database mode has not been set
+     */
+    private static function mapToOrderBy(Field $field): string
+    {
+        $mode = Configuration::mode('render ORDER BY clause');
+
+        if (str_contains($field->fieldName, ' ')) {
+            $parts = explode(' ', $field->fieldName);
+            $field->fieldName = array_shift($parts);
+            $direction = ' ' . implode(' ', $parts);
+        } else {
+            $direction = '';
+        }
+
+        if (str_starts_with($field->fieldName, 'n:')) {
+            $field->fieldName = substr($field->fieldName, 2);
+            $value = match ($mode) {
+                Mode::PgSQL => '(' . $field->path() .  ')::numeric',
+                Mode::SQLite => $field->path()
+            };
+        } elseif (str_starts_with($field->fieldName, 'i:')) {
+            $field->fieldName = substr($field->fieldName, 2);
+            $value = match ($mode) {
+                Mode::PgSQL => 'LOWER(' . $field->path() . ')',
+                Mode::SQLite => $field->path() . ' COLLATE NOCASE'
+            };
+        } else {
+            $value = $field->path();
+        }
+
+        return (empty($field->qualifier) ? '' : "$field->qualifier.") . $value . $direction;
+    }
+
+    /**
+     * Create an `ORDER BY` clause ('n:' treats field as number, 'i:' does case-insensitive ordering)
+     *
+     * @param Field[] $fields The fields, named for the field plus directions (ex. 'field DESC NULLS FIRST')
+     * @return string The ORDER BY clause with the given fields
+     * @throws Exception If the database mode has not been set
+     */
+    public static function orderBy(array $fields): string
+    {
+        return empty($fields) ? "" : ' ORDER BY ' . implode(', ', array_map(self::mapToOrderBy(...), $fields));
+    }
 }

src/Query/Count.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Query;
 

src/Query/Definition.php

@@ -1,8 +1,15 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Query;
 
 use BitBadger\PDODocument\{Configuration, DocumentException, DocumentIndex, Mode};
+use Exception;
 
 /**
  * Queries to define tables and indexes
@@ -14,14 +21,13 @@ class Definition
      *
      * @param string $name The name of the table (including schema, if applicable)
      * @return string The CREATE TABLE statement for the document table
-     * @throws DocumentException If the database mode has not been set
+     * @throws Exception If the database mode has not been set
      */
     public static function ensureTable(string $name): string
     {
-        $dataType = match (Configuration::$mode) {
+        $dataType = match (Configuration::mode('make create table statement')) {
             Mode::PgSQL  => 'JSONB',
             Mode::SQLite => 'TEXT',
-            default      => throw new DocumentException('Database mode not set; cannot make create table statement')
         };
         return "CREATE TABLE IF NOT EXISTS $name (data $dataType NOT NULL)";
     }
@@ -35,7 +41,7 @@ class Definition
     private static function splitSchemaAndTable(string $tableName): array
     {
         $parts = explode('.', $tableName);
-        return sizeof($parts) == 1 ? ["", $tableName] : [$parts[0], $parts[1]];
+        return sizeof($parts) === 1 ? ["", $tableName] : [$parts[0], $parts[1]];
     }
 
     /**
@@ -43,7 +49,7 @@ class Definition
      *
      * @param string $tableName The name of the table which should be indexed
      * @param string $indexName The name of the index to create
-     * @param array $fields An array of fields to be indexed; may contain direction (ex. 'salary DESC')
+     * @param string[] $fields An array of fields to be indexed; may contain direction (ex. 'salary DESC')
      * @return string The CREATE INDEX statement to ensure the index exists
      */
     public static function ensureIndexOn(string $tableName, string $indexName, array $fields): string
@@ -51,7 +57,7 @@ class Definition
         [, $tbl] = self::splitSchemaAndTable($tableName);
         $jsonFields = implode(', ', array_map(function (string $field) {
             $parts     = explode(' ', $field);
-            $fieldName = sizeof($parts) == 1 ? $field : $parts[0];
+            $fieldName = sizeof($parts) === 1 ? $field : $parts[0];
             $direction = sizeof($parts) < 2 ? "" : " $parts[1]";
             return "(data->>'$fieldName')$direction";
         }, $fields));
@@ -75,17 +81,17 @@ class Definition
      * @param string $tableName The name of the table on which the document index should be created
      * @param DocumentIndex $indexType The type of index to be created
      * @return string The SQL statement to create an index on JSON documents in the specified table
-     * @throws DocumentException If the database mode is not PostgreSQL
+     * @throws Exception|DocumentException If the database mode is not PostgreSQL
      */
     public static function ensureDocumentIndexOn(string $tableName, DocumentIndex $indexType): string
     {
-        if (Configuration::$mode <> Mode::PgSQL) {
+        if (Configuration::mode() <> Mode::PgSQL) {
             throw new DocumentException('Document indexes are only supported on PostgreSQL');
         }
         [, $tbl]  = self::splitSchemaAndTable($tableName);
         $extraOps = match ($indexType) {
-            DocumentIndex::Full => '',
-            DocumentIndex::Optimized => ' jsonb_path_ops'
+            DocumentIndex::Full      => '',
+            DocumentIndex::Optimized => ' jsonb_path_ops',
         };
         return "CREATE INDEX IF NOT EXISTS idx_{$tbl}_document ON $tableName USING GIN (data$extraOps)";
     }

src/Query/Delete.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Query;
 

src/Query/Exists.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Query;
 

src/Query/Find.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Query;
 

src/Query/Patch.php

@@ -1,8 +1,15 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Query;
 
 use BitBadger\PDODocument\{Configuration, DocumentException, Field, FieldMatch, Mode, Query};
+use Exception;
 
 /**
  * Queries to perform partial updates on documents
@@ -15,14 +22,13 @@ class Patch
      * @param string $tableName The name of the table in which documents should be patched
      * @param string $whereClause The body of the WHERE clause to use in the UPDATE statement
      * @return string The UPDATE statement to perform the patch
-     * @throws DocumentException If the database mode has not been set
+     * @throws Exception If the database mode has not been set
      */
     public static function update(string $tableName, string $whereClause): string
     {
-        $setValue = match (Configuration::$mode) {
+        $setValue = match (Configuration::mode('make patch statement')) {
             Mode::PgSQL  => 'data || :data',
             Mode::SQLite => 'json_patch(data, json(:data))',
-            default      => throw new DocumentException('Database mode not set; cannot make patch statement')
         };
         return "UPDATE $tableName SET data = $setValue WHERE $whereClause";
     }

src/Query/RemoveFields.php

@@ -1,8 +1,15 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument\Query;
 
 use BitBadger\PDODocument\{Configuration, DocumentException, Field, FieldMatch, Mode, Query};
+use Exception;
 
 /**
  * Queries to remove fields from documents
@@ -17,30 +24,26 @@ class RemoveFields
      * Create an UPDATE statement to remove fields from a JSON document
      *
      * @param string $tableName The name of the table in which documents should be manipulated
-     * @param array $parameters The parameter list for the query
+     * @param array<string, mixed> $parameters The parameter list for the query
      * @param string $whereClause The body of the WHERE clause for the update
      * @return string The UPDATE statement to remove fields from a JSON document
-     * @throws DocumentException If the database mode has not been set
+     * @throws Exception If the database mode has not been set
      */
     public static function update(string $tableName, array $parameters, string $whereClause): string
     {
-        switch (Configuration::$mode) {
-            case Mode::PgSQL:
-                return "UPDATE $tableName SET data = data - " . array_keys($parameters)[0]
-                    . "::text[] WHERE $whereClause";
-            case Mode::SQLite:
-                $paramNames = implode(', ', array_keys($parameters));
-                return "UPDATE $tableName SET data = json_remove(data, $paramNames) WHERE $whereClause";
-            default:
-                throw new DocumentException('Database mode not set; cannot generate field removal query');
-        }
+        return match (Configuration::mode('generate field removal query')) {
+            Mode::PgSQL  => "UPDATE $tableName SET data = data - " . array_keys($parameters)[0]
+                                . "::text[] WHERE $whereClause",
+            Mode::SQLite => "UPDATE $tableName SET data = json_remove(data, " . implode(', ', array_keys($parameters))
+                                . ") WHERE $whereClause",
+        };
     }
 
     /**
      * Query to remove fields from a document by the document's ID
      *
      * @param string $tableName The name of the table in which the document should be manipulated
-     * @param array $parameters The parameter list for the query
+     * @param array<string, mixed> $parameters The parameter list for the query
      * @param mixed $docId The ID of the document from which fields should be removed (optional; string ID assumed)
      * @return string The UPDATE statement to remove fields from a document by its ID
      * @throws DocumentException If the database mode has not been set
@@ -54,8 +57,8 @@ class RemoveFields
      * Query to remove fields from documents via a comparison on JSON fields within the document
      *
      * @param string $tableName The name of the table in which documents should be manipulated
-     * @param array|Field[] $fields The field comparison to match
-     * @param array $parameters The parameter list for the query
+     * @param Field[] $fields The field comparison to match
+     * @param array<string, mixed> $parameters The parameter list for the query
      * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
      * @return string The UPDATE statement to remove fields from documents via field comparison
      * @throws DocumentException If the database mode has not been set
@@ -70,7 +73,7 @@ class RemoveFields
      * Query to remove fields from documents via a JSON containment query (PostgreSQL only)
      *
      * @param string $tableName The name of the table in which documents should be manipulated
-     * @param array $parameters The parameter list for the query
+     * @param array<string, mixed> $parameters The parameter list for the query
      * @return string The UPDATE statement to remove fields from documents via a JSON containment query
      * @throws DocumentException If the database mode is not PostgreSQL
      */
@@ -83,7 +86,7 @@ class RemoveFields
      * Query to remove fields from documents via a JSON Path match query (PostgreSQL only)
      *
      * @param string $tableName The name of the table in which documents should be manipulated
-     * @param array $parameters The parameter list for the query
+     * @param array<string, mixed> $parameters The parameter list for the query
      * @return string The UPDATE statement to remove fields from documents via a JSON Path match
      * @throws DocumentException
      */

src/RemoveFields.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace BitBadger\PDODocument;
 
@@ -12,7 +18,7 @@ class RemoveFields
      *
      * @param string $tableName The table in which the document should have fields removed
      * @param mixed $docId The ID of the document from which fields should be removed
-     * @param array|string[] $fieldNames The names of the fields to be removed
+     * @param string[] $fieldNames The names of the fields to be removed
      * @throws DocumentException If any is encountered
      */
     public static function byId(string $tableName, mixed $docId, array $fieldNames): void
@@ -26,8 +32,8 @@ class RemoveFields
      * Remove fields from documents via a comparison on a JSON field in the document
      *
      * @param string $tableName The table in which documents should have fields removed
-     * @param array|Field[] $fields The field comparison to match
-     * @param array|string[] $fieldNames The names of the fields to be removed
+     * @param Field[] $fields The field comparison to match
+     * @param string[] $fieldNames The names of the fields to be removed
      * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
      * @throws DocumentException If any is encountered
      */
@@ -35,17 +41,17 @@ class RemoveFields
                                     ?FieldMatch $match = null): void
     {
         $nameParams  = Parameters::fieldNames(':name', $fieldNames);
-        $namedFields = Parameters::nameFields($fields);
-        Custom::nonQuery(Query\RemoveFields::byFields($tableName, $namedFields, $nameParams, $match),
-            Parameters::addFields($namedFields, $nameParams));
+        Parameters::nameFields($fields);
+        Custom::nonQuery(Query\RemoveFields::byFields($tableName, $fields, $nameParams, $match),
+            Parameters::addFields($fields, $nameParams));
     }
 
     /**
      * Remove fields from documents via a JSON containment query (`@>`; PostgreSQL only)
      *
      * @param string $tableName The table in which documents should have fields removed
-     * @param array|object $criteria The JSON containment query values
-     * @param array|string[] $fieldNames The names of the fields to be removed
+     * @param mixed[]|object $criteria The JSON containment query values
+     * @param string[] $fieldNames The names of the fields to be removed
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */
     public static function byContains(string $tableName, array|object $criteria, array $fieldNames): void
@@ -60,7 +66,7 @@ class RemoveFields
      *
      * @param string $tableName The table in which documents should have fields removed
      * @param string $path The JSON Path match string
-     * @param array|string[] $fieldNames The names of the fields to be removed
+     * @param string[] $fieldNames The names of the fields to be removed
      * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
      */
     public static function byJsonPath(string $tableName, string $path, array $fieldNames): void

tests/PjsonDocument.php

@@ -0,0 +1,22 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+namespace Test;
+
+use Square\Pjson\{Json, JsonSerialize};
+
+/**
+ * A test document annotated with pjson attributes using the `JsonSerialize` trait
+ */
+class PjsonDocument
+{
+    use JsonSerialize;
+
+    public function __construct(#[Json] public PjsonId $id = new PjsonId(''), #[Json] public string $name = '',
+                                #[Json('num_value')] public int $numValue = 0, public string $skipped = 'yep') { }
+}

tests/PjsonId.php

@@ -0,0 +1,34 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+namespace Test;
+
+use Square\Pjson\JsonDataSerializable;
+
+/**
+ * A serializable ID wrapper class
+ */
+final class PjsonId implements JsonDataSerializable
+{
+    public function __construct(protected string $value) { }
+
+    public function toJsonData(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * @param mixed $jd JSON data
+     * @param mixed[]|string $path path segments
+     * @return static
+     */
+    public static function fromJsonData($jd, array|string $path = []): static
+    {
+        return new static($jd);
+    }
+}

tests/integration/ArrayDocument.php

@@ -0,0 +1,35 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+namespace Test\Integration;
+
+/**
+ * A document with an array of values
+ */
+class ArrayDocument
+{
+    /**
+     * @param string $id The ID of the document
+     * @param string[] $values The values for the document
+     */
+    public function __construct(public string $id = '', public array $values = []) { }
+
+    /**
+     * A set of documents used for integration tests
+     *
+     * @return ArrayDocument[] Test documents for InArray tests
+     */
+    public static function testDocuments(): array
+    {
+        return [
+            new ArrayDocument('first', ['a', 'b', 'c']),
+            new ArrayDocument('second', ['c', 'd', 'e']),
+            new ArrayDocument('third', ['x', 'y', 'z'])
+        ];
+    }
+}

tests/integration/NumDocument.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration;
 

tests/integration/SubDocument.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration;
 

tests/integration/TestDocument.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration;
 

tests/integration/postgresql/CountTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
@@ -27,44 +33,49 @@ class CountTest extends TestCase
         parent::tearDown();
     }
 
+    #[TestDox('all() succeeds')]
     public function testAllSucceeds(): void
     {
         $count = Count::all(ThrowawayDb::TABLE);
         $this->assertEquals(5, $count, 'There should have been 5 matching documents');
     }
 
+    #[TestDox('byFields() succeeds for a numeric range')]
     public function testByFieldsSucceedsForANumericRange(): void
     {
-        $count = Count::byFields(ThrowawayDb::TABLE, [Field::BT('num_value', 10, 20)]);
+        $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('num_value', 10, 20)]);
         $this->assertEquals(3, $count, 'There should have been 3 matching documents');
     }
 
+    #[TestDox('byFields() succeeds for a non-numeric range')]
     public function testByFieldsSucceedsForANonNumericRange(): void
     {
-        $count = Count::byFields(ThrowawayDb::TABLE, [Field::BT('value', 'aardvark', 'apple')]);
+        $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('value', 'aardvark', 'apple')]);
         $this->assertEquals(1, $count, 'There should have been 1 matching document');
     }
 
+    #[TestDox('byContains() succeeds when documents match')]
     public function testByContainsSucceedsWhenDocumentsMatch(): void
     {
         $this->assertEquals(2, Count::byContains(ThrowawayDb::TABLE, ['value' => 'purple']),
             'There should have been 2 matching documents');
     }
 
+    #[TestDox('byContains() succeeds when no documents match')]
     public function testByContainsSucceedsWhenNoDocumentsMatch(): void
     {
         $this->assertEquals(0, Count::byContains(ThrowawayDb::TABLE, ['value' => 'magenta']),
             'There should have been no matching documents');
     }
 
-    #[TestDox('By JSON Path succeeds when documents match')]
+    #[TestDox('byJsonPath() succeeds when documents match')]
     public function testByJsonPathSucceedsWhenDocumentsMatch(): void
     {
         $this->assertEquals(2, Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ < 5)'),
             'There should have been 2 matching documents');
     }
 
-    #[TestDox('By JSON Path succeeds when no documents match')]
+    #[TestDox('byJsonPath() succeeds when no documents match')]
     public function testByJsonPathSucceedsWhenNoDocumentsMatch(): void
     {
         $this->assertEquals(0, Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)'),

tests/integration/postgresql/CustomTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
@@ -28,7 +34,8 @@ class CustomTest extends TestCase
         ThrowawayDb::destroy($this->dbName);
     }
 
-    public function testRunQuerySucceedsWithAValidQuery()
+    #[TestDox('runQuery() succeeds with a valid query')]
+    public function testRunQuerySucceedsWithAValidQuery(): void
     {
         $stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []);
         try {
@@ -38,7 +45,8 @@ class CustomTest extends TestCase
         }
     }
 
-    public function testRunQueryFailsWithAnInvalidQuery()
+    #[TestDox('runQuery() fails with an invalid query')]
+    public function testRunQueryFailsWithAnInvalidQuery(): void
     {
         $this->expectException(DocumentException::class);
         $stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []);
@@ -49,25 +57,28 @@ class CustomTest extends TestCase
         }
     }
 
-    public function testListSucceedsWhenDataIsFound()
+    #[TestDox('list() succeeds when data is found')]
+    public function testListSucceedsWhenDataIsFound(): void
     {
         $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'The document list should not be null');
         $count = 0;
-        foreach ($list->items() as $ignored) $count++;
+        foreach ($list->items as $ignored) $count++;
         $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
     }
 
-    public function testListSucceedsWhenNoDataIsFound()
+    #[TestDox('list() succeeds when no data is found')]
+    public function testListSucceedsWhenNoDataIsFound(): void
     {
         $list = Custom::list(
             Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE (data->>'num_value')::numeric > :value",
             [':value' => 100], new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'The document list should not be null');
-        $this->assertFalse($list->hasItems(), 'There should have been no documents in the list');
+        $this->assertFalse($list->hasItems, 'There should have been no documents in the list');
     }
 
-    public function testArraySucceedsWhenDataIsFound()
+    #[TestDox('array() succeeds when data is found')]
+    public function testArraySucceedsWhenDataIsFound(): void
     {
         $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [],
             new DocumentMapper(TestDocument::class));
@@ -75,7 +86,8 @@ class CustomTest extends TestCase
         $this->assertCount(2, $array, 'There should have been 2 documents in the array');
     }
 
-    public function testArraySucceedsWhenNoDataIsFound()
+    #[TestDox('array() succeeds when no data is found')]
+    public function testArraySucceedsWhenNoDataIsFound(): void
     {
         $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value",
             [':value' => 'not there'], new DocumentMapper(TestDocument::class));
@@ -83,29 +95,33 @@ class CustomTest extends TestCase
         $this->assertCount(0, $array, 'There should have been no documents in the array');
     }
 
+    #[TestDox('single() succeeds when a row is found')]
     public function testSingleSucceedsWhenARowIsFound(): void
     {
         $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'],
             new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($doc, 'There should have been a document returned');
-        $this->assertEquals('one', $doc->id, 'The incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('one', $doc->value->id, 'The incorrect document was returned');
     }
 
+    #[TestDox('single() succeeds when a row is not found')]
     public function testSingleSucceedsWhenARowIsNotFound(): void
     {
         $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id",
             [':id' => 'eighty'], new DocumentMapper(TestDocument::class));
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 
-    public function testNonQuerySucceedsWhenOperatingOnData()
+    #[TestDox('nonQuery() succeeds when operating on data')]
+    public function testNonQuerySucceedsWhenOperatingOnData(): void
     {
         Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
         $remaining = Count::all(ThrowawayDb::TABLE);
         $this->assertEquals(0, $remaining, 'There should be no documents remaining in the table');
     }
 
-    public function testNonQuerySucceedsWhenNoDataMatchesWhereClause()
+    #[TestDox('nonQuery() succeeds when no data matches WHERE clause')]
+    public function testNonQuerySucceedsWhenNoDataMatchesWhereClause(): void
     {
         Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE (data->>'num_value')::numeric > :value",
             [':value' => 100]);
@@ -113,7 +129,8 @@ class CustomTest extends TestCase
         $this->assertEquals(5, $remaining, 'There should be 5 documents remaining in the table');
     }
 
-    public function testScalarSucceeds()
+    #[TestDox('scalar() succeeds')]
+    public function testScalarSucceeds(): void
     {
         $value = Custom::scalar("SELECT 5 AS it", [], new CountMapper());
         $this->assertEquals(5, $value, 'The scalar value was not returned correctly');

tests/integration/postgresql/DefinitionTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
@@ -41,6 +47,7 @@ class DefinitionTest extends TestCase
             [':name' => $name], new ExistsMapper());
     }
 
+    #[TestDox('ensureTable() succeeds')]
     public function testEnsureTableSucceeds(): void
     {
         $this->assertFalse($this->itExists('ensured'), 'The table should not exist already');
@@ -50,6 +57,7 @@ class DefinitionTest extends TestCase
         $this->assertTrue($this->itExists('idx_ensured_key'), 'The key index should now exist');
     }
 
+    #[TestDox('ensureFieldIndex() succeeds')]
     public function testEnsureFieldIndexSucceeds(): void
     {
         $this->assertFalse($this->itExists('idx_ensured_test'), 'The index should not exist already');
@@ -58,6 +66,7 @@ class DefinitionTest extends TestCase
         $this->assertTrue($this->itExists('idx_ensured_test'), 'The index should now exist');
     }
 
+    #[TestDox('ensureDocumentIndex() succeeds for Full')]
     public function testEnsureDocumentIndexSucceedsForFull(): void
     {
         $docIdx = 'idx_' . ThrowawayDb::TABLE . '_document';
@@ -67,6 +76,7 @@ class DefinitionTest extends TestCase
         $this->assertTrue($this->itExists($docIdx), 'The document index should now exist');
     }
 
+    #[TestDox('ensureDocumentIndex() succeeds for Optimized')]
     public function testEnsureDocumentIndexSucceedsForOptimized(): void
     {
         $docIdx = 'idx_' . ThrowawayDb::TABLE . '_document';

tests/integration/postgresql/DeleteTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
@@ -27,7 +33,7 @@ class DeleteTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('By ID succeeds when a document is deleted')]
+    #[TestDox('byId() succeeds when a document is deleted')]
     public function testByIdSucceedsWhenADocumentIsDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@@ -35,7 +41,7 @@ class DeleteTest extends TestCase
         $this->assertEquals(4, Count::all(ThrowawayDb::TABLE), 'There should have been 4 documents remaining');
     }
 
-    #[TestDox('By ID succeeds when a document is not deleted')]
+    #[TestDox('byId() succeeds when a document is not deleted')]
     public function testByIdSucceedsWhenADocumentIsNotDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@@ -43,20 +49,23 @@ class DeleteTest extends TestCase
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
     }
 
+    #[TestDox('byFields() succeeds when documents are deleted')]
     public function testByFieldsSucceedsWhenDocumentsAreDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byFields(ThrowawayDb::TABLE, [Field::NE('value', 'purple')]);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notEqual('value', 'purple')]);
         $this->assertEquals(2, Count::all(ThrowawayDb::TABLE), 'There should have been 2 documents remaining');
     }
 
+    #[TestDox('byFields() succeeds when documents are not deleted')]
     public function testByFieldsSucceedsWhenDocumentsAreNotDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'crimson')]);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'crimson')]);
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
     }
 
+    #[TestDox('byContains() succeeds when documents are deleted')]
     public function testByContainsSucceedsWhenDocumentsAreDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@@ -64,6 +73,7 @@ class DeleteTest extends TestCase
         $this->assertEquals(3, Count::all(ThrowawayDb::TABLE), 'There should have been 3 documents remaining');
     }
 
+    #[TestDox('byContains() succeeds when documents are not deleted')]
     public function testByContainsSucceedsWhenDocumentsAreNotDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@@ -71,7 +81,7 @@ class DeleteTest extends TestCase
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
     }
 
-    #[TestDox('By JSON Path succeeds when documents are deleted')]
+    #[TestDox('byJsonPath() succeeds when documents are deleted')]
     public function testByJsonPathSucceedsWhenDocumentsAreDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@@ -79,7 +89,7 @@ class DeleteTest extends TestCase
         $this->assertEquals(1, Count::all(ThrowawayDb::TABLE), 'There should have been 1 document remaining');
     }
 
-    #[TestDox('By JSON Path succeeds when documents are not deleted')]
+    #[TestDox('byJsonPath() succeeds when documents are not deleted')]
     public function testByJsonPathSucceedsWhenDocumentsAreNotDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');

tests/integration/postgresql/DocumentListTest.php

@@ -1,8 +1,14 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
-use BitBadger\PDODocument\{DocumentList, Query};
+use BitBadger\PDODocument\{DocumentException, DocumentList, Query};
 use BitBadger\PDODocument\Mapper\DocumentMapper;
 use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
@@ -29,6 +35,7 @@ class DocumentListTest extends TestCase
         parent::tearDown();
     }
 
+    #[TestDox('create() succeeds')]
     public function testCreateSucceeds(): void
     {
         $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@@ -37,13 +44,14 @@ class DocumentListTest extends TestCase
         $list = null;
     }
 
-    public function testItems(): void
+    #[TestDox('items succeeds')]
+    public function testItemsSucceeds(): void
     {
         $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
             new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'There should have been a document list created');
         $count = 0;
-        foreach ($list->items() as $item) {
+        foreach ($list->items as $item) {
             $this->assertContains($item->id, ['one', 'two', 'three', 'four', 'five'],
                 'An unexpected document ID was returned');
             $count++;
@@ -51,24 +59,77 @@ class DocumentListTest extends TestCase
         $this->assertEquals(5, $count, 'There should have been 5 documents returned');
     }
 
+    #[TestDox('items fails when already consumed')]
+    public function testItemsFailsWhenAlreadyConsumed(): void
+    {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        $this->assertNotNull($list, 'There should have been a document list created');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        $ignored = iterator_to_array($list->items);
+        $this->assertFalse($list->hasItems, 'The list should no longer have items');
+        $this->expectException(DocumentException::class);
+        iterator_to_array($list->items);
+    }
+
+    #[TestDox('hasItems succeeds with empty results')]
     public function testHasItemsSucceedsWithEmptyResults(): void
     {
         $list = DocumentList::create(
             Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE (data->>'num_value')::numeric < 0", [],
             new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertFalse($list->hasItems(), 'There should be no items in the list');
+        $this->assertFalse($list->hasItems, 'There should be no items in the list');
     }
 
+    #[TestDox('hasItems succeeds with non-empty results')]
     public function testHasItemsSucceedsWithNonEmptyResults(): void
     {
         $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
             new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems(), 'There should be items in the list');
-        foreach ($list->items() as $ignored) {
-            $this->assertTrue($list->hasItems(), 'There should be items remaining in the list');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        foreach ($list->items as $ignored) {
+            $this->assertTrue($list->hasItems, 'There should be items remaining in the list');
         }
-        $this->assertFalse($list->hasItems(), 'There should be no remaining items in the list');
+        $this->assertFalse($list->hasItems, 'There should be no remaining items in the list');
+    }
+
+    #[TestDox('map() succeeds')]
+    public function testMapSucceeds(): void
+    {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        $this->assertNotNull($list, 'There should have been a document list created');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        foreach ($list->map(fn($doc) => strrev($doc->id)) as $mapped) {
+            $this->assertContains($mapped, ['eno', 'owt', 'eerht', 'ruof', 'evif'],
+                'An unexpected mapped value was returned');
+        }
+    }
+
+    #[TestDox('iter() succeeds')]
+    public function testIterSucceeds(): void
+    {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        $this->assertNotNull($list, 'There should have been a document list created');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        $splats = [];
+        $list->iter(function ($doc) use (&$splats) { $splats[] = str_repeat('*', strlen($doc->id)); });
+        $this->assertEquals('*** *** ***** **** ****', implode(' ', $splats),
+            'Iteration did not have the expected result');
+    }
+
+    #[TestDox('mapToArray() succeeds')]
+    public function testMapToArraySucceeds(): void
+    {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        $this->assertNotNull($list, 'There should have been a document list created');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        $lookup   = $list->mapToArray(fn($it) => $it->id, fn($it) => $it->value);
+        $expected = ['one' => 'FIRST!', 'two' => 'another', 'three' => '', 'four' => 'purple', 'five' => 'purple'];
+        $this->assertEquals($expected, $lookup, 'The array was not mapped correctly');
     }
 }

tests/integration/postgresql/DocumentTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
@@ -29,12 +35,13 @@ class DocumentTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('Insert succeeds for array no auto ID')]
+    #[TestDox('insert() succeeds for array no auto ID')]
     public function testInsertSucceedsForArrayNoAutoId(): void
     {
         Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]);
-        $doc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document inserted');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
+        $this->assertTrue($tryDoc->isSome, 'There should have been a document inserted');
+        $doc = $tryDoc->value;
         $this->assertEquals('turkey', $doc->id, 'The ID was incorrect');
         $this->assertEquals('', $doc->value, 'The value was incorrect');
         $this->assertEquals(0, $doc->num_value, 'The numeric value was incorrect');
@@ -43,7 +50,7 @@ class DocumentTest extends TestCase
         $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
     }
 
-    #[TestDox('Insert succeeds for array with auto number ID not provided')]
+    #[TestDox('insert() succeeds for array with auto number ID not provided')]
     public function testInsertSucceedsForArrayWithAutoNumberIdNotProvided(): void
     {
         Configuration::$autoId = AutoId::Number;
@@ -52,22 +59,22 @@ class DocumentTest extends TestCase
 
             Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'new', 'num_value' => 8]);
             $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $obj = json_decode($doc['data']);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $obj = json_decode($doc->value['data']);
             $this->assertEquals(1, $obj->id, 'The ID 1 should have been auto-generated');
 
             Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'again', 'num_value' => 7]);
             $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE " . Query::whereById(docId: 2),
                 [':id' => 2], new ArrayMapper());
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $obj = json_decode($doc['data']);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $obj = json_decode($doc->value['data']);
             $this->assertEquals(2, $obj->id, 'The ID 2 should have been auto-generated');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto number ID with ID provided')]
+    #[TestDox('insert() succeeds for array with auto number ID with ID provided')]
     public function testInsertSucceedsForArrayWithAutoNumberIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::Number;
@@ -75,30 +82,30 @@ class DocumentTest extends TestCase
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, ['id' => 7, 'value' => 'new', 'num_value' => 8]);
             $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $obj = json_decode($doc['data']);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $obj = json_decode($doc->value['data']);
             $this->assertEquals(7, $obj->id, 'The ID 7 should have been stored');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto UUID ID not provided')]
+    #[TestDox('insert() succeeds for array with auto UUID ID not provided')]
     public function testInsertSucceedsForArrayWithAutoUuidIdNotProvided(): void
     {
         Configuration::$autoId = AutoId::UUID;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 5)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertNotEmpty($doc->id, 'The ID should have been auto-generated');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 5)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertNotEmpty($doc->value->id, 'The ID should have been auto-generated');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto UUID ID with ID provided')]
+    #[TestDox('insert() succeeds for array with auto UUID ID with ID provided')]
     public function testInsertSucceedsForArrayWithAutoUuidIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::UUID;
@@ -106,15 +113,15 @@ class DocumentTest extends TestCase
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             $uuid = AutoId::generateUUID();
             Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 12)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals($uuid, $doc->id, 'The ID should not have been changed');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 12)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals($uuid, $doc->value->id, 'The ID should not have been changed');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto string ID not provided')]
+    #[TestDox('insert() succeeds for array with auto string ID not provided')]
     public function testInsertSucceedsForArrayWithAutoStringIdNotProvided(): void
     {
         Configuration::$autoId         = AutoId::RandomString;
@@ -122,36 +129,38 @@ class DocumentTest extends TestCase
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 8)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(6, strlen($doc->id), 'The ID should have been auto-generated and had 6 characters');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 8)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(6, strlen($doc->value->id),
+                'The ID should have been auto-generated and had 6 characters');
         } finally {
             Configuration::$autoId         = AutoId::None;
             Configuration::$idStringLength = 16;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto string ID with ID provided')]
+    #[TestDox('insert() succeeds for array with auto string ID with ID provided')]
     public function testInsertSucceedsForArrayWithAutoStringIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::RandomString;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 3)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals('my-key', $doc->id, 'The ID should not have been changed');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals('my-key', $doc->value->id, 'The ID should not have been changed');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object no auto ID')]
+    #[TestDox('insert() succeeds for object no auto ID')]
     public function testInsertSucceedsForObjectNoAutoId(): void
     {
         Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble')));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document inserted');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
+        $this->assertTrue($tryDoc->isSome, 'There should have been a document inserted');
+        $doc = $tryDoc->value;
         $this->assertEquals('turkey', $doc->id, 'The ID was incorrect');
         $this->assertEquals('', $doc->value, 'The value was incorrect');
         $this->assertEquals(0, $doc->num_value, 'The numeric value was incorrect');
@@ -160,7 +169,7 @@ class DocumentTest extends TestCase
         $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
     }
 
-    #[TestDox('Insert succeeds for object with auto number ID not provided')]
+    #[TestDox('insert() succeeds for object with auto number ID not provided')]
     public function testInsertSucceedsForObjectWithAutoNumberIdNotProvided(): void
     {
         Configuration::$autoId = AutoId::Number;
@@ -168,50 +177,50 @@ class DocumentTest extends TestCase
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
 
             Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'taco')], NumDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(1, $doc->id, 'The ID 1 should have been auto-generated');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'taco')], NumDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(1, $doc->value->id, 'The ID 1 should have been auto-generated');
 
             Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'burrito')], NumDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(2, $doc->id, 'The ID 2 should have been auto-generated');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'burrito')], NumDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(2, $doc->value->id, 'The ID 2 should have been auto-generated');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto number ID with ID provided')]
+    #[TestDox('insert() succeeds for object with auto number ID with ID provided')]
     public function testInsertSucceedsForObjectWithAutoNumberIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::Number;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'large')], NumDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(64, $doc->id, 'The ID 64 should have been stored');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'large')], NumDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(64, $doc->value->id, 'The ID 64 should have been stored');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto UUID ID not provided')]
+    #[TestDox('insert() succeeds for object with auto UUID ID not provided')]
     public function testInsertSucceedsForObjectWithAutoUuidIdNotProvided(): void
     {
         Configuration::$autoId = AutoId::UUID;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EX('value')], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertNotEmpty($doc->id, 'The ID should have been auto-generated');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::exists('value')], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertNotEmpty($doc->value->id, 'The ID should have been auto-generated');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto UUID ID with ID provided')]
+    #[TestDox('insert() succeeds for object with auto UUID ID with ID provided')]
     public function testInsertSucceedsForObjectWithAutoUuidIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::UUID;
@@ -219,15 +228,15 @@ class DocumentTest extends TestCase
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             $uuid = AutoId::generateUUID();
             Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 14)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals($uuid, $doc->id, 'The ID should not have been changed');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 14)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals($uuid, $doc->value->id, 'The ID should not have been changed');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto string ID not provided')]
+    #[TestDox('insert() succeeds for object with auto string ID not provided')]
     public function testInsertSucceedsForObjectWithAutoStringIdNotProvided(): void
     {
         Configuration::$autoId         = AutoId::RandomString;
@@ -235,57 +244,64 @@ class DocumentTest extends TestCase
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 55)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(40, strlen($doc->id), 'The ID should have been auto-generated and had 40 characters');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 55)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(40, strlen($doc->value->id),
+                'The ID should have been auto-generated and had 40 characters');
         } finally {
             Configuration::$autoId         = AutoId::None;
             Configuration::$idStringLength = 16;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto string ID with ID provided')]
+    #[TestDox('insert() succeeds for object with auto string ID with ID provided')]
     public function testInsertSucceedsForObjectWithAutoStringIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::RandomString;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 3)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals('my-key', $doc->id, 'The ID should not have been changed');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals('my-key', $doc->value->id, 'The ID should not have been changed');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
+    #[TestDox('insert() fails for duplicate key')]
     public function testInsertFailsForDuplicateKey(): void
     {
         $this->expectException(DocumentException::class);
         Document::insert(ThrowawayDb::TABLE, new TestDocument('one'));
     }
 
+    #[TestDox('save() succeeds when a document is inserted')]
     public function testSaveSucceedsWhenADocumentIsInserted(): void
     {
         Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b')));
         $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
     }
 
+    #[TestDox('save() succeeds when a document is updated')]
     public function testSaveSucceedsWhenADocumentIsUpdated(): void
     {
         Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
+        $doc = $tryDoc->value;
         $this->assertEquals(44, $doc->num_value, 'The numeric value was not updated');
         $this->assertNull($doc->sub, 'The sub-document should have been null');
     }
 
+    #[TestDox('update() succeeds when replacing a document')]
     public function testUpdateSucceedsWhenReplacingADocument(): void
     {
         Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z')));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
+        $this->assertNotFalse($tryDoc->isSome, 'There should have been a document returned');
+        $doc = $tryDoc->value;
         $this->assertEquals('howdy', $doc->value, 'The value was incorrect');
         $this->assertEquals(8, $doc->num_value, 'The numeric value was incorrect');
         $this->assertNotNull($doc->sub, 'The sub-document should not have been null');
@@ -293,10 +309,11 @@ class DocumentTest extends TestCase
         $this->assertEquals('z', $doc->sub->bar, 'The sub-document bar property was incorrect');
     }
 
+    #[TestDox('update() succeeds when no document is replaced')]
     public function testUpdateSucceedsWhenNoDocumentIsReplaced(): void
     {
         Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200'));
         $doc = Find::byId(ThrowawayDb::TABLE, 'two-hundred', TestDocument::class);
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 }

tests/integration/postgresql/ExistsTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
@@ -27,51 +33,55 @@ class ExistsTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('By ID succeeds when a document exists')]
+    #[TestDox('byId() succeeds when a document exists')]
     public function testByIdSucceedsWhenADocumentExists(): void
     {
         $this->assertTrue(Exists::byId(ThrowawayDb::TABLE, 'three'), 'There should have been an existing document');
     }
 
-    #[TestDox('By ID succeeds when a document does not exist')]
+    #[TestDox('byId() succeeds when a document does not exist')]
     public function testByIdSucceedsWhenADocumentDoesNotExist(): void
     {
         $this->assertFalse(Exists::byId(ThrowawayDb::TABLE, 'seven'),
             'There should not have been an existing document');
     }
 
+    #[TestDox('byFields() succeeds when documents exist')]
     public function testByFieldsSucceedsWhenDocumentsExist(): void
     {
-        $this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 10)]),
+        $this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 10)]),
             'There should have been existing documents');
     }
 
+    #[TestDox('byFields() succeeds when no matching documents exist')]
     public function testByFieldsSucceedsWhenNoMatchingDocumentsExist(): void
     {
-        $this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::LT('nothing', 'none')]),
+        $this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::less('nothing', 'none')]),
             'There should not have been any existing documents');
     }
 
+    #[TestDox('byContains() succeeds when documents exist')]
     public function testByContainsSucceedsWhenDocumentsExist(): void
     {
         $this->assertTrue(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'purple']),
             'There should have been existing documents');
     }
 
+    #[TestDox('byContains() succeeds when no matching documents exist')]
     public function testByContainsSucceedsWhenNoMatchingDocumentsExist(): void
     {
         $this->assertFalse(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'violet']),
             'There should not have been existing documents');
     }
 
-    #[TestDox('By JSON Path succeeds when documents exist')]
+    #[TestDox('byJsonPath() succeeds when documents exist')]
     public function testByJsonPathSucceedsWhenDocumentsExist(): void
     {
         $this->assertTrue(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)'),
             'There should have been existing documents');
     }
 
-    #[TestDox('By JSON Path succeeds when no matching documents exist')]
+    #[TestDox('byJsonPath() succeeds when no matching documents exist')]
     public function testByJsonPathSucceedsWhenNoMatchingDocumentsExist(): void
     {
         $this->assertFalse(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10.1)'),

tests/integration/postgresql/FindTest.php

@@ -1,11 +1,17 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
-use BitBadger\PDODocument\{Custom, Delete, Document, Field, Find};
+use BitBadger\PDODocument\{Custom, Delete, Document, Field, FieldMatch, Find};
 use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
-use Test\Integration\{NumDocument, TestDocument};
+use Test\Integration\{ArrayDocument, NumDocument, TestDocument};
 
 /**
  * PostgreSQL integration tests for the Find class
@@ -28,157 +34,302 @@ class FindTest extends TestCase
         parent::tearDown();
     }
 
+    #[TestDox('all() succeeds when there is data')]
     public function testAllSucceedsWhenThereIsData(): void
     {
         $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
         $count = 0;
-        foreach ($docs->items() as $ignored) $count++;
+        foreach ($docs->items as $ignored) $count++;
         $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
     }
 
+    #[TestDox('all() succeeds when ordering data ascending')]
+    public function testAllSucceedsWhenOrderingDataAscending(): void
+    {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['five', 'four', 'one', 'three', 'two'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('all() succeeds when ordering data descending')]
+    public function testAllSucceedsWhenOrderingDataDescending(): void
+    {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id DESC')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['two', 'three', 'one', 'four', 'five'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('all() succeeds when ordering data numerically')]
+    public function testAllSucceedsWhenOrderingDataNumerically(): void
+    {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class,
+            [Field::named('sub.foo NULLS LAST'), Field::named('n:num_value')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['two', 'four', 'one', 'three', 'five'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('all() succeeds when there is no data')]
     public function testAllSucceedsWhenThereIsNoData(): void
     {
         Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
         $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
+        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
     }
 
-    #[TestDox('By ID succeeds when a document is found')]
+    #[TestDox('byId() succeeds when a document is found')]
     public function testByIdSucceedsWhenADocumentIsFound(): void
     {
         $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertEquals('two', $doc->id, 'An incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('two', $doc->value->id, 'An incorrect document was returned');
     }
 
-    #[TestDox('By ID succeeds when a document is found with numeric ID')]
+    #[TestDox('byId() succeeds when a document is found with numeric ID')]
     public function testByIdSucceedsWhenADocumentIsFoundWithNumericId(): void
     {
-        Delete::byFields(ThrowawayDb::TABLE, [Field::NEX('absent')]);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absent')]);
         Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']);
         $doc = Find::byId(ThrowawayDb::TABLE, 18, NumDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertEquals(18, $doc->id, 'An incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals(18, $doc->value->id, 'An incorrect document was returned');
     }
 
-    #[TestDox('By ID succeeds when a document is not found')]
+    #[TestDox('byId() succeeds when a document is not found')]
     public function testByIdSucceedsWhenADocumentIsNotFound(): void
     {
         $doc = Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class);
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 
+    #[TestDox('byFields() succeeds when documents are found')]
     public function testByFieldsSucceedsWhenDocumentsAreFound(): void
     {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::GT('num_value', 15)], TestDocument::class);
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('value', ['blue', 'purple']), Field::exists('sub')],
+            TestDocument::class, FieldMatch::All);
         $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
         $count = 0;
-        foreach ($docs->items() as $ignored) $count++;
+        foreach ($docs->items as $ignored) $count++;
+        $this->assertEquals(1, $count, 'There should have been 1 document in the list');
+    }
+
+    #[TestDox('byFields() succeeds when documents are found and ordered')]
+    public function testByFieldsSucceedsWhenDocumentsAreFoundAndOrdered(): void
+    {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], TestDocument::class,
+            FieldMatch::All, [Field::named('id')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['five', 'four'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('byFields() succeeds when documents are found using IN with numeric field')]
+    public function testByFieldsSucceedsWhenDocumentsAreFoundUsingInWithNumericField(): void
+    {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('num_value', [2, 4, 6, 8])], TestDocument::class);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        $this->assertEquals(1, $count, 'There should have been 1 document in the list');
+    }
+
+    #[TestDox('byFields() succeeds when no documents are found')]
+    public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void
+    {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::greater('num_value', 100)], TestDocument::class);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
+    }
+
+    #[TestDox('byFields() succeeds for inArray when matching documents exist')]
+    public function testByFieldsSucceedsForInArrayWhenMatchingDocumentsExist(): void
+    {
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
+        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['c'])],
+            ArrayDocument::class);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
         $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
     }
 
-    public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void
+    #[TestDox('byFields() succeeds for inArray when no matching documents exist')]
+    public function testByFieldsSucceedsForInArrayWhenNoMatchingDocumentsExist(): void
     {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::GT('num_value', 100)], TestDocument::class);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
+        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['j'])],
+            ArrayDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
+        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
     }
 
+    #[TestDox('byContains() succeeds when documents are found')]
     public function testByContainsSucceedsWhenDocumentsAreFound(): void
     {
         $docs = Find::byContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
         $count = 0;
-        foreach ($docs->items() as $ignored) $count++;
+        foreach ($docs->items as $ignored) $count++;
         $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
     }
 
+    #[TestDox('byContains() succeeds when documents are found and ordered')]
+    public function testByContainsSucceedsWhenDocumentsAreFoundAndOrdered(): void
+    {
+        $docs = Find::byContains(ThrowawayDb::TABLE, ['sub' => ['foo' => 'green']], TestDocument::class,
+            [Field::named('value')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['two', 'four'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('byContains() succeeds when no documents are found')]
     public function testByContainsSucceedsWhenNoDocumentsAreFound(): void
     {
         $docs = Find::byContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems(), 'The document list should be empty');
+        $this->assertFalse($docs->hasItems, 'The document list should be empty');
     }
 
-    #[TestDox('By JSON Path succeeds when documents are found')]
+    #[TestDox('byJsonPath() succeeds when documents are found')]
     public function testByJsonPathSucceedsWhenDocumentsAreFound(): void
     {
         $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
         $count = 0;
-        foreach ($docs->items() as $ignored) $count++;
+        foreach ($docs->items as $ignored) $count++;
         $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
     }
 
-    #[TestDox('By JSON Path succeeds when no documents are found')]
+    #[TestDox('byJsonPath() succeeds when documents are found and ordered')]
+    public function testByJsonPathSucceedsWhenDocumentsAreFoundAndOrdered(): void
+    {
+        $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class,
+            [Field::named('id')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['five', 'four'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('byJsonPath() succeeds when no documents are found')]
     public function testByJsonPathSucceedsWhenNoDocumentsAreFound(): void
     {
         $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems(), 'The document list should be empty');
+        $this->assertFalse($docs->hasItems, 'The document list should be empty');
     }
 
+    #[TestDox('firstByFields() succeeds when a document is found')]
     public function testFirstByFieldsSucceedsWhenADocumentIsFound(): void
     {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'another')], TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertEquals('two', $doc->id, 'The incorrect document was returned');
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'another')], TestDocument::class);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('two', $doc->value->id, 'The incorrect document was returned');
     }
 
+    #[TestDox('firstByFields() succeeds when multiple documents are found')]
     public function testFirstByFieldsSucceedsWhenMultipleDocumentsAreFound(): void
     {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('sub.foo', 'green')], TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertContains($doc->id, ['two', 'four'], 'An incorrect document was returned');
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertContains($doc->value->id, ['two', 'four'], 'An incorrect document was returned');
     }
 
+    #[TestDox('firstByFields() succeeds when multiple ordered documents are found')]
+    public function testFirstByFieldsSucceedsWhenMultipleOrderedDocumentsAreFound(): void
+    {
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class,
+            orderBy: [Field::named('n:num_value DESC')]);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('four', $doc->value->id, 'The incorrect document was returned');
+    }
+
+    #[TestDox('firstByFields() succeeds when a document is not found')]
     public function testFirstByFieldsSucceedsWhenADocumentIsNotFound(): void
     {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'absent')], TestDocument::class);
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'absent')], TestDocument::class);
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 
+    #[TestDox('firstByContains() succeeds when a document is found')]
     public function testFirstByContainsSucceedsWhenADocumentIsFound(): void
     {
         $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'FIRST!'], TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertEquals('one', $doc->id, 'The incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('one', $doc->value->id, 'The incorrect document was returned');
     }
 
+    #[TestDox('firstByContains() succeeds when multiple documents are found')]
     public function testFirstByContainsSucceedsWhenMultipleDocumentsAreFound(): void
     {
         $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertContains($doc->id, ['four', 'five'], 'An incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertContains($doc->value->id, ['four', 'five'], 'An incorrect document was returned');
     }
 
+    #[TestDox('firstByContains() succeeds when multiple ordered documents are found')]
+    public function testFirstByContainsSucceedsWhenMultipleOrderedDocumentsAreFound(): void
+    {
+        $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class,
+            [Field::named('sub.bar NULLS FIRST')]);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('five', $doc->value->id, 'The incorrect document was returned');
+    }
+
+    #[TestDox('firstByContains() succeeds when a document is not found')]
     public function testFirstByContainsSucceedsWhenADocumentIsNotFound(): void
     {
         $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class);
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 
-    #[TestDox('First by JSON Path succeeds when a document is found')]
+    #[TestDox('firstByJsonPath() succeeds when a document is found')]
     public function testFirstByJsonPathSucceedsWhenADocumentIsFound(): void
     {
         $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)', TestDocument::class);
-        $this->assertEquals('two', $doc->id, 'The incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('two', $doc->value->id, 'The incorrect document was returned');
     }
 
-    #[TestDox('First by JSON Path succeeds when multiple documents are found')]
+    #[TestDox('firstByJsonPath() succeeds when multiple documents are found')]
     public function testFirstByJsonPathSucceedsWhenMultipleDocumentsAreFound(): void
     {
         $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertContains($doc->id, ['four', 'five'], 'An incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertContains($doc->value->id, ['four', 'five'], 'An incorrect document was returned');
     }
 
-    #[TestDox('First by JSON Path succeeds when a document is not found')]
+    #[TestDox('firstByJsonPath() succeeds when multiple ordered documents are found')]
+    public function testFirstByJsonPathSucceedsWhenMultipleOrderedDocumentsAreFound(): void
+    {
+        $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class,
+            [Field::named('id DESC')]);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('four', $doc->value->id, 'The incorrect document was returned');
+    }
+
+    #[TestDox('firstByJsonPath() succeeds when a document is not found')]
     public function testFirstByJsonPathSucceedsWhenADocumentIsNotFound(): void
     {
         $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class);
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 }

tests/integration/postgresql/PatchTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
@@ -28,16 +34,16 @@ class PatchTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('By ID succeeds when a document is updated')]
+    #[TestDox('byId() succeeds when a document is updated')]
     public function testByIdSucceedsWhenADocumentIsUpdated(): void
     {
         Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]);
         $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertEquals(44, $doc->num_value, 'The updated document is not correct');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals(44, $doc->value->num_value, 'The updated document is not correct');
     }
 
-    #[TestDox('By ID succeeds when no document is updated')]
+    #[TestDox('byId() succeeds when no document is updated')]
     public function testByIdSucceedsWhenNoDocumentIsUpdated(): void
     {
         $id = 'forty-seven';
@@ -46,30 +52,35 @@ class PatchTest extends TestCase
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byFields() succeeds when a document is updated')]
     public function testByFieldsSucceedsWhenADocumentIsUpdated(): void
     {
-        Patch::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'purple')], ['num_value' => 77]);
-        $after = Count::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 77)]);
+        Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], ['num_value' => 77]);
+        $after = Count::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 77)]);
         $this->assertEquals(2, $after, 'There should have been 2 documents updated');
     }
 
+    #[TestDox('byFields() succeeds when no document is updated')]
     public function testByFieldsSucceedsWhenNoDocumentIsUpdated(): void
     {
-        $fields = [Field::EQ('value', 'burgundy')];
+        $fields = [Field::equal('value', 'burgundy')];
         $this->assertEquals(0, Count::byFields(ThrowawayDb::TABLE, $fields), 'There should be no matching documents');
         Patch::byFields(ThrowawayDb::TABLE, $fields, ['foo' => 'green']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byContains() succeeds when documents are updated')]
     public function testByContainsSucceedsWhenDocumentsAreUpdated(): void
     {
         Patch::byContains(ThrowawayDb::TABLE, ['value' => 'another'], ['num_value' => 12]);
-        $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'another'], TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
+        $tryDoc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'another'], TestDocument::class);
+        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
+        $doc = $tryDoc->value;
         $this->assertEquals('two', $doc->id, 'An incorrect document was returned');
         $this->assertEquals(12, $doc->num_value, 'The document was not patched');
     }
 
+    #[TestDox('byContains() succeeds when no documents are updated')]
     public function testByContainsSucceedsWhenNoDocumentsAreUpdated(): void
     {
         $criteria = ['value' => 'updated'];
@@ -79,20 +90,20 @@ class PatchTest extends TestCase
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
-    #[TestDox('By JSON Path succeeds when documents are updated')]
+    #[TestDox('byJsonPath() succeeds when documents are updated')]
     public function testByJsonPathSucceedsWhenDocumentsAreUpdated(): void
     {
         Patch::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', ['value' => 'blue']);
         $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems(), 'The document list should not be empty');
-        foreach ($docs->items() as $item) {
+        $this->assertTrue($docs->hasItems, 'The document list should not be empty');
+        foreach ($docs->items as $item) {
             $this->assertContains($item->id, ['four', 'five'], 'An incorrect document was returned');
             $this->assertEquals('blue', $item->value, 'The document was not patched');
         }
     }
 
-    #[TestDox('By JSON Path succeeds when documents are not updated')]
+    #[TestDox('byJsonPath() succeeds when documents are not updated')]
     public function testByJsonPathSucceedsWhenDocumentsAreNotUpdated(): void
     {
         $path = '$.num_value ? (@ > 100)';

tests/integration/postgresql/RemoveFieldsTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
@@ -28,97 +34,104 @@ class RemoveFieldsTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('By ID succeeds when fields are removed')]
+    #[TestDox('byId() succeeds when fields are removed')]
     public function testByIdSucceedsWhenFieldsAreRemoved(): void
     {
         RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']);
-        $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
+        $doc = $tryDoc->value;
         $this->assertEquals('', $doc->value, 'Value should have been blank (its default value)');
         $this->assertNull($doc->sub, 'Sub-document should have been null');
     }
 
-    #[TestDox('By ID succeeds when a field is not removed')]
+    #[TestDox('byId() succeeds when a field is not removed')]
     public function testByIdSucceedsWhenAFieldIsNotRemoved(): void
     {
         RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
-    #[TestDox('By ID succeeds when no document is matched')]
+    #[TestDox('byId() succeeds when no document is matched')]
     public function testByIdSucceedsWhenNoDocumentIsMatched(): void
     {
         RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byFields() succeeds when a field is removed')]
     public function testByFieldsSucceedsWhenAFieldIsRemoved(): void
     {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], ['sub']);
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertNull($doc->sub, 'Sub-document should have been null');
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['sub']);
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], TestDocument::class);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertNull($doc->value->sub, 'Sub-document should have been null');
     }
 
+    #[TestDox('byFields() succeeds when a field is not removed')]
     public function testByFieldsSucceedsWhenAFieldIsNotRemoved(): void
     {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], ['nada']);
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['nada']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byFields() succeeds when no document is matched')]
     public function testByFieldsSucceedsWhenNoDocumentIsMatched(): void
     {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::NE('missing', 'nope')], ['value']);
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')], ['value']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byContains() succeeds when a field is removed')]
     public function testByContainsSucceedsWhenAFieldIsRemoved(): void
     {
         $criteria = ['sub' => ['foo' => 'green']];
         RemoveFields::byContains(ThrowawayDb::TABLE, $criteria, ['value']);
         $docs = Find::byContains(ThrowawayDb::TABLE, $criteria, TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems(), 'The document list should not have been empty');
-        foreach ($docs->items() as $item) {
+        $this->assertTrue($docs->hasItems, 'The document list should not have been empty');
+        foreach ($docs->items as $item) {
             $this->assertContains($item->id, ['two', 'four'], 'An incorrect document was returned');
             $this->assertEquals('', $item->value, 'The value field was not removed');
         }
     }
 
+    #[TestDox('byContains() succeeds when a field is not removed')]
     public function testByContainsSucceedsWhenAFieldIsNotRemoved(): void
     {
         RemoveFields::byContains(ThrowawayDb::TABLE, ['sub' => ['foo' => 'green']], ['invalid_field']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byContains() succeeds when no document is matched')]
     public function testByContainsSucceedsWhenNoDocumentIsMatched(): void
     {
         RemoveFields::byContains(ThrowawayDb::TABLE, ['value' => 'substantial'], ['num_value']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
-    #[TestDox('By JSON Path succeeds when a field is removed')]
+    #[TestDox('byJsonPath() succeeds when a field is removed')]
     public function testByJsonPathSucceedsWhenAFieldIsRemoved(): void
     {
         $path = '$.value ? (@ == "purple")';
         RemoveFields::byJsonPath(ThrowawayDb::TABLE, $path, ['sub']);
         $docs = Find::byJsonPath(ThrowawayDb::TABLE, $path, TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertTrue($docs->hasItems(), 'The document list should not have been empty');
-        foreach ($docs->items() as $item) {
+        $this->assertTrue($docs->hasItems, 'The document list should not have been empty');
+        foreach ($docs->items as $item) {
             $this->assertContains($item->id, ['four', 'five'], 'An incorrect document was returned');
             $this->assertNull($item->sub, 'The sub field was not removed');
         }
     }
 
-    #[TestDox('By JSON Path succeeds when a field is not removed')]
+    #[TestDox('byJsonPath() succeeds when a field is not removed')]
     public function testByJsonPathSucceedsWhenAFieldIsNotRemoved(): void
     {
         RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "purple")', ['submarine']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
-    #[TestDox('By JSON Path succeeds when no document is matched')]
+    #[TestDox('byJsonPath() succeeds when no document is matched')]
     public function testByJsonPathSucceedsWhenNoDocumentIsMatched(): void
     {
         RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "mauve")', ['value']);

tests/integration/postgresql/ThrowawayDb.php

@@ -1,8 +1,15 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ * @see https://github.com/Zaid-Ajaj/ThrowawayDb The origin concept
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\PostgreSQL;
 
-use BitBadger\PDODocument\{AutoId, Configuration, Custom, Definition, Document, DocumentException, Mode};
+use BitBadger\PDODocument\{AutoId, Configuration, Custom, Definition, Document, DocumentException};
 use Random\RandomException;
 use Test\Integration\{SubDocument, TestDocument};
 
@@ -12,21 +19,21 @@ use Test\Integration\{SubDocument, TestDocument};
 class ThrowawayDb
 {
     /** @var string The table used for document manipulation */
-    public const TABLE = "test_table";
+    public const TABLE = 'test_table';
 
     /**
      * Configure the document library for the given database (or the main PostgreSQL connection, if the database name
      * is not provided; this is used for creating and dropping databases)
      *
      * @param string|null $dbName The name of the database to configure (optional, defaults to env or "postgres")
+     * @throws DocumentException If any is encountered
      */
     private static function configure(?string $dbName = null): void
     {
-        Configuration::$pdoDSN = sprintf("pgsql:host=%s;dbname=%s", $_ENV['PDO_DOC_PGSQL_HOST'] ?? 'localhost',
-            $dbName ?? $_ENV['PDO_DOC_PGSQL_DB'] ?? 'postgres');
+        Configuration::useDSN(sprintf("pgsql:host=%s;dbname=%s", $_ENV['PDO_DOC_PGSQL_HOST'] ?? 'localhost',
+            $dbName ?? $_ENV['PDO_DOC_PGSQL_DB'] ?? 'postgres'));
         Configuration::$username = $_ENV['PDO_DOC_PGSQL_USER'] ?? 'postgres';
         Configuration::$password = $_ENV['PDO_DOC_PGSQL_PASS'] ?? 'postgres';
-        Configuration::$mode = Mode::PgSQL;
         Configuration::resetPDO();
     }
 
@@ -66,10 +73,9 @@ class ThrowawayDb
     {
         self::configure();
         Custom::nonQuery("DROP DATABASE IF EXISTS $dbName WITH (FORCE)", []);
-        Configuration::$pdoDSN   = '';
+        Configuration::useDSN('');
         Configuration::$username = null;
         Configuration::$password = null;
-        Configuration::$mode     = null;
         Configuration::resetPDO();
     }
 }

tests/integration/sqlite/CountTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
@@ -27,31 +33,35 @@ class CountTest extends TestCase
         parent::tearDown();
     }
 
+    #[TestDox('all() succeeds')]
     public function testAllSucceeds(): void
     {
         $count = Count::all(ThrowawayDb::TABLE);
         $this->assertEquals(5, $count, 'There should have been 5 matching documents');
     }
 
+    #[TestDox('byFields() succeeds for a numeric range')]
     public function testByFieldsSucceedsForANumericRange(): void
     {
-        $count = Count::byFields(ThrowawayDb::TABLE, [Field::BT('num_value', 10, 20)]);
+        $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('num_value', 10, 20)]);
         $this->assertEquals(3, $count, 'There should have been 3 matching documents');
     }
 
+    #[TestDox('byFields() succeeds for a non-numeric range')]
     public function testByFieldsSucceedsForANonNumericRange(): void
     {
-        $count = Count::byFields(ThrowawayDb::TABLE, [Field::BT('value', 'aardvark', 'apple')]);
+        $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('value', 'aardvark', 'apple')]);
         $this->assertEquals(1, $count, 'There should have been 1 matching document');
     }
 
+    #[TestDox('byContains() fails')]
     public function testByContainsFails(): void
     {
         $this->expectException(DocumentException::class);
         Count::byContains('', []);
     }
 
-    #[TestDox('By JSON Path fails')]
+    #[TestDox('byJsonPath() fails')]
     public function testByJsonPathFails(): void
     {
         $this->expectException(DocumentException::class);

tests/integration/sqlite/CustomTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
@@ -28,7 +34,8 @@ class CustomTest extends TestCase
         ThrowawayDb::destroy($this->dbName);
     }
 
-    public function testRunQuerySucceedsWithAValidQuery()
+    #[TestDox('runQuery() succeeds with a valid query')]
+    public function testRunQuerySucceedsWithAValidQuery(): void
     {
         $stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []);
         try {
@@ -38,7 +45,8 @@ class CustomTest extends TestCase
         }
     }
 
-    public function testRunQueryFailsWithAnInvalidQuery()
+    #[TestDox('runQuery() fails with an invalid query')]
+    public function testRunQueryFailsWithAnInvalidQuery(): void
     {
         $this->expectException(DocumentException::class);
         $stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []);
@@ -49,24 +57,28 @@ class CustomTest extends TestCase
         }
     }
 
-    public function testListSucceedsWhenDataIsFound()
+    #[TestDox('list() succeeds when data is found')]
+    public function testListSucceedsWhenDataIsFound(): void
     {
         $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'The document list should not be null');
+        $this->assertTrue($list->hasItems, 'There should have been documents in the list');
         $count = 0;
-        foreach ($list->items() as $ignored) $count++;
+        foreach ($list->items as $ignored) $count++;
         $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
     }
 
-    public function testListSucceedsWhenNoDataIsFound()
+    #[TestDox('list() succeeds when no data is found')]
+    public function testListSucceedsWhenNoDataIsFound(): void
     {
         $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' > :value",
             [':value' => 100], new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'The document list should not be null');
-        $this->assertFalse($list->hasItems(), 'There should have been no documents in the list');
+        $this->assertFalse($list->hasItems, 'There should have been no documents in the list');
     }
 
-    public function testArraySucceedsWhenDataIsFound()
+    #[TestDox('array() succeeds when data is found')]
+    public function testArraySucceedsWhenDataIsFound(): void
     {
         $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [],
             new DocumentMapper(TestDocument::class));
@@ -74,7 +86,8 @@ class CustomTest extends TestCase
         $this->assertCount(2, $array, 'There should have been 2 documents in the array');
     }
 
-    public function testArraySucceedsWhenNoDataIsFound()
+    #[TestDox('array() succeeds when no data is found')]
+    public function testArraySucceedsWhenNoDataIsFound(): void
     {
         $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value",
             [':value' => 'not there'], new DocumentMapper(TestDocument::class));
@@ -82,36 +95,41 @@ class CustomTest extends TestCase
         $this->assertCount(0, $array, 'There should have been no documents in the array');
     }
 
+    #[TestDox('single() succeeds when a row is found')]
     public function testSingleSucceedsWhenARowIsFound(): void
     {
         $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'],
             new DocumentMapper(TestDocument::class));
-        $this->assertNotNull($doc, 'There should have been a document returned');
-        $this->assertEquals('one', $doc->id, 'The incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('one', $doc->value->id, 'The incorrect document was returned');
     }
 
+    #[TestDox('single() succeeds when a row is not found')]
     public function testSingleSucceedsWhenARowIsNotFound(): void
     {
         $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id",
             [':id' => 'eighty'], new DocumentMapper(TestDocument::class));
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 
-    public function testNonQuerySucceedsWhenOperatingOnData()
+    #[TestDox('nonQuery() succeeds when operating on data')]
+    public function testNonQuerySucceedsWhenOperatingOnData(): void
     {
         Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
         $remaining = Count::all(ThrowawayDb::TABLE);
         $this->assertEquals(0, $remaining, 'There should be no documents remaining in the table');
     }
 
-    public function testNonQuerySucceedsWhenNoDataMatchesWhereClause()
+    #[TestDox('nonQuery() succeeds when no data matches WHERE clause')]
+    public function testNonQuerySucceedsWhenNoDataMatchesWhereClause(): void
     {
         Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE data->>'num_value' > :value", [':value' => 100]);
         $remaining = Count::all(ThrowawayDb::TABLE);
         $this->assertEquals(5, $remaining, 'There should be 5 documents remaining in the table');
     }
 
-    public function testScalarSucceeds()
+    #[TestDox('scalar() succeeds')]
+    public function testScalarSucceeds(): void
     {
         $value = Custom::scalar("SELECT 5 AS it", [], new CountMapper());
         $this->assertEquals(5, $value, 'The scalar value was not returned correctly');

tests/integration/sqlite/DefinitionTest.php

@@ -1,4 +1,10 @@
 <?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
@@ -41,6 +47,7 @@ class DefinitionTest extends TestCase
             [':name' => $name], new ExistsMapper());
     }
 
+    #[TestDox('ensureTable() succeeds')]
     public function testEnsureTableSucceeds(): void
     {
         $this->assertFalse($this->itExists('ensured'), 'The table should not exist already');
@@ -50,6 +57,7 @@ class DefinitionTest extends TestCase
         $this->assertTrue($this->itExists('idx_ensured_key'), 'The key index should now exist');
     }
 
+    #[TestDox('ensureFieldIndex() succeeds')]
     public function testEnsureFieldIndexSucceeds(): void
     {
         $this->assertFalse($this->itExists('idx_ensured_test'), 'The index should not exist already');
@@ -58,6 +66,7 @@ class DefinitionTest extends TestCase
         $this->assertTrue($this->itExists('idx_ensured_test'), 'The index should now exist');
     }
 
+    #[TestDox('ensureDocumentIndex() fails')]
     public function testEnsureDocumentIndexFails(): void
     {
         $this->expectException(DocumentException::class);

tests/integration/sqlite/DeleteTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
@@ -27,7 +33,7 @@ class DeleteTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('By ID succeeds when a document is deleted')]
+    #[TestDox('byId() succeeds when a document is deleted')]
     public function testByIdSucceedsWhenADocumentIsDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@@ -35,7 +41,7 @@ class DeleteTest extends TestCase
         $this->assertEquals(4, Count::all(ThrowawayDb::TABLE), 'There should have been 4 documents remaining');
     }
 
-    #[TestDox('By ID succeeds when a document is not deleted')]
+    #[TestDox('byId() succeeds when a document is not deleted')]
     public function testByIdSucceedsWhenADocumentIsNotDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@@ -43,27 +49,30 @@ class DeleteTest extends TestCase
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
     }
 
+    #[TestDox('byFields() succeeds when documents are deleted')]
     public function testByFieldsSucceedsWhenDocumentsAreDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byFields(ThrowawayDb::TABLE, [Field::NE('value', 'purple')]);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notEqual('value', 'purple')]);
         $this->assertEquals(2, Count::all(ThrowawayDb::TABLE), 'There should have been 2 documents remaining');
     }
 
+    #[TestDox('byFields() succeeds when documents are not deleted')]
     public function testByFieldsSucceedsWhenDocumentsAreNotDeleted(): void
     {
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
-        Delete::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'crimson')]);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'crimson')]);
         $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
     }
 
+    #[TestDox('byContains() fails')]
     public function testByContainsFails(): void
     {
         $this->expectException(DocumentException::class);
         Delete::byContains('', []);
     }
 
-    #[TestDox('By JSON Path fails')]
+    #[TestDox('byJsonPath() fails')]
     public function testByJsonPathFails(): void
     {
         $this->expectException(DocumentException::class);

tests/integration/sqlite/DocumentListTest.php

@@ -1,8 +1,14 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
-use BitBadger\PDODocument\{DocumentList, Query};
+use BitBadger\PDODocument\{DocumentException, DocumentList, Query};
 use BitBadger\PDODocument\Mapper\DocumentMapper;
 use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
@@ -29,6 +35,7 @@ class DocumentListTest extends TestCase
         parent::tearDown();
     }
 
+    #[TestDox('create() succeeds')]
     public function testCreateSucceeds(): void
     {
         $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@@ -37,13 +44,14 @@ class DocumentListTest extends TestCase
         $list = null;
     }
 
-    public function testItems(): void
+    #[TestDox('items succeeds')]
+    public function testItemsSucceeds(): void
     {
         $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
             new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'There should have been a document list created');
         $count = 0;
-        foreach ($list->items() as $item) {
+        foreach ($list->items as $item) {
             $this->assertContains($item->id, ['one', 'two', 'three', 'four', 'five'],
                 'An unexpected document ID was returned');
             $count++;
@@ -51,23 +59,76 @@ class DocumentListTest extends TestCase
         $this->assertEquals(5, $count, 'There should have been 5 documents returned');
     }
 
+    #[TestDox('items fails when already consumed')]
+    public function testItemsFailsWhenAlreadyConsumed(): void
+    {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        $this->assertNotNull($list, 'There should have been a document list created');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        $ignored = iterator_to_array($list->items);
+        $this->assertFalse($list->hasItems, 'The list should no longer have items');
+        $this->expectException(DocumentException::class);
+        iterator_to_array($list->items);
+    }
+
+    #[TestDox('hasItems succeeds with empty results')]
     public function testHasItemsSucceedsWithEmptyResults(): void
     {
         $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' < 0", [],
             new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertFalse($list->hasItems(), 'There should be no items in the list');
+        $this->assertFalse($list->hasItems, 'There should be no items in the list');
     }
 
+    #[TestDox('hasItems succeeds with non-empty results')]
     public function testHasItemsSucceedsWithNonEmptyResults(): void
     {
         $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
             new DocumentMapper(TestDocument::class));
         $this->assertNotNull($list, 'There should have been a document list created');
-        $this->assertTrue($list->hasItems(), 'There should be items in the list');
-        foreach ($list->items() as $ignored) {
-            $this->assertTrue($list->hasItems(), 'There should be items remaining in the list');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        foreach ($list->items as $ignored) {
+            $this->assertTrue($list->hasItems, 'There should be items remaining in the list');
         }
-        $this->assertFalse($list->hasItems(), 'There should be no remaining items in the list');
+        $this->assertFalse($list->hasItems, 'There should be no remaining items in the list');
+    }
+
+    #[TestDox('map() succeeds')]
+    public function testMapSucceeds(): void
+    {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        $this->assertNotNull($list, 'There should have been a document list created');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        foreach ($list->map(fn($doc) => strrev($doc->id)) as $mapped) {
+            $this->assertContains($mapped, ['eno', 'owt', 'eerht', 'ruof', 'evif'],
+                'An unexpected mapped value was returned');
+        }
+    }
+
+    #[TestDox('iter() succeeds')]
+    public function testIterSucceeds(): void
+    {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        $this->assertNotNull($list, 'There should have been a document list created');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        $splats = [];
+        $list->iter(function ($doc) use (&$splats) { $splats[] = str_repeat('*', strlen($doc->id)); });
+        $this->assertEquals('*** *** ***** **** ****', implode(' ', $splats),
+            'Iteration did not have the expected result');
+    }
+
+    #[TestDox('mapToArray() succeeds')]
+    public function testMapToArraySucceeds(): void
+    {
+        $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
+            new DocumentMapper(TestDocument::class));
+        $this->assertNotNull($list, 'There should have been a document list created');
+        $this->assertTrue($list->hasItems, 'There should be items in the list');
+        $lookup   = $list->mapToArray(fn($it) => $it->id, fn($it) => $it->value);
+        $expected = ['one' => 'FIRST!', 'two' => 'another', 'three' => '', 'four' => 'purple', 'five' => 'purple'];
+        $this->assertEquals($expected, $lookup, 'The array was not mapped correctly');
     }
 }

tests/integration/sqlite/DocumentTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
@@ -29,12 +35,13 @@ class DocumentTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('Insert succeeds for array no auto ID')]
+    #[TestDox('insert() succeeds for array no auto ID')]
     public function testInsertSucceedsForArrayNoAutoId(): void
     {
         Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]);
-        $doc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document inserted');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
+        $this->assertTrue($tryDoc->isSome, 'There should have been a document inserted');
+        $doc = $tryDoc->value;
         $this->assertEquals('turkey', $doc->id, 'The ID was incorrect');
         $this->assertEquals('', $doc->value, 'The value was incorrect');
         $this->assertEquals(0, $doc->num_value, 'The numeric value was incorrect');
@@ -43,7 +50,7 @@ class DocumentTest extends TestCase
         $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
     }
 
-    #[TestDox('Insert succeeds for array with auto number ID not provided')]
+    #[TestDox('insert() succeeds for array with auto number ID not provided')]
     public function testInsertSucceedsForArrayWithAutoNumberIdNotProvided(): void
     {
         Configuration::$autoId = AutoId::Number;
@@ -52,22 +59,22 @@ class DocumentTest extends TestCase
 
             Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'new', 'num_value' => 8]);
             $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $obj = json_decode($doc['data']);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $obj = json_decode($doc->value['data']);
             $this->assertEquals(1, $obj->id, 'The ID 1 should have been auto-generated');
 
             Document::insert(ThrowawayDb::TABLE, ['id' => 0, 'value' => 'again', 'num_value' => 7]);
             $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = 2", [],
                 new ArrayMapper());
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $obj = json_decode($doc['data']);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $obj = json_decode($doc->value['data']);
             $this->assertEquals(2, $obj->id, 'The ID 2 should have been auto-generated');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto number ID with ID provided')]
+    #[TestDox('insert() succeeds for array with auto number ID with ID provided')]
     public function testInsertSucceedsForArrayWithAutoNumberIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::Number;
@@ -75,30 +82,30 @@ class DocumentTest extends TestCase
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, ['id' => 7, 'value' => 'new', 'num_value' => 8]);
             $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE, [], new ArrayMapper());
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $obj = json_decode($doc['data']);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $obj = json_decode($doc->value['data']);
             $this->assertEquals(7, $obj->id, 'The ID 7 should have been stored');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto UUID ID not provided')]
+    #[TestDox('insert() succeeds for array with auto UUID ID not provided')]
     public function testInsertSucceedsForArrayWithAutoUuidIdNotProvided(): void
     {
         Configuration::$autoId = AutoId::UUID;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 5)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertNotEmpty($doc->id, 'The ID should have been auto-generated');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 5)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertNotEmpty($doc->value->id, 'The ID should have been auto-generated');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto UUID ID with ID provided')]
+    #[TestDox('insert() succeeds for array with auto UUID ID with ID provided')]
     public function testInsertSucceedsForArrayWithAutoUuidIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::UUID;
@@ -106,15 +113,15 @@ class DocumentTest extends TestCase
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             $uuid = AutoId::generateUUID();
             Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 12)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals($uuid, $doc->id, 'The ID should not have been changed');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 12)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals($uuid, $doc->value->id, 'The ID should not have been changed');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto string ID not provided')]
+    #[TestDox('insert() succeeds for array with auto string ID not provided')]
     public function testInsertSucceedsForArrayWithAutoStringIdNotProvided(): void
     {
         Configuration::$autoId         = AutoId::RandomString;
@@ -122,36 +129,38 @@ class DocumentTest extends TestCase
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 8)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(6, strlen($doc->id), 'The ID should have been auto-generated and had 6 characters');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 8)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(6, strlen($doc->value->id),
+                'The ID should have been auto-generated and had 6 characters');
         } finally {
             Configuration::$autoId         = AutoId::None;
             Configuration::$idStringLength = 16;
         }
     }
 
-    #[TestDox('Insert succeeds for array with auto string ID with ID provided')]
+    #[TestDox('insert() succeeds for array with auto string ID with ID provided')]
     public function testInsertSucceedsForArrayWithAutoStringIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::RandomString;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]);
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 3)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals('my-key', $doc->id, 'The ID should not have been changed');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals('my-key', $doc->value->id, 'The ID should not have been changed');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object no auto ID')]
+    #[TestDox('insert() succeeds for object no auto ID')]
     public function testInsertSucceedsForObjectNoAutoId(): void
     {
         Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble')));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document inserted');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'turkey', TestDocument::class);
+        $this->assertNotFalse($tryDoc->isSome, 'There should have been a document inserted');
+        $doc = $tryDoc->value;
         $this->assertEquals('turkey', $doc->id, 'The ID was incorrect');
         $this->assertEquals('', $doc->value, 'The value was incorrect');
         $this->assertEquals(0, $doc->num_value, 'The numeric value was incorrect');
@@ -160,7 +169,7 @@ class DocumentTest extends TestCase
         $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
     }
 
-    #[TestDox('Insert succeeds for object with auto number ID not provided')]
+    #[TestDox('insert() succeeds for object with auto number ID not provided')]
     public function testInsertSucceedsForObjectWithAutoNumberIdNotProvided(): void
     {
         Configuration::$autoId = AutoId::Number;
@@ -168,50 +177,50 @@ class DocumentTest extends TestCase
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
 
             Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'taco')], NumDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(1, $doc->id, 'The ID 1 should have been auto-generated');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'taco')], NumDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(1, $doc->value->id, 'The ID 1 should have been auto-generated');
 
             Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'burrito')], NumDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(2, $doc->id, 'The ID 2 should have been auto-generated');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'burrito')], NumDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(2, $doc->value->id, 'The ID 2 should have been auto-generated');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto number ID with ID provided')]
+    #[TestDox('insert() succeeds for object with auto number ID with ID provided')]
     public function testInsertSucceedsForObjectWithAutoNumberIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::Number;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large'));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'large')], NumDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(64, $doc->id, 'The ID 64 should have been stored');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'large')], NumDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(64, $doc->value->id, 'The ID 64 should have been stored');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto UUID ID not provided')]
+    #[TestDox('insert() succeeds for object with auto UUID ID not provided')]
     public function testInsertSucceedsForObjectWithAutoUuidIdNotProvided(): void
     {
         Configuration::$autoId = AutoId::UUID;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EX('value')], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertNotEmpty($doc->id, 'The ID should have been auto-generated');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::exists('value')], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertNotEmpty($doc->value->id, 'The ID should have been auto-generated');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto UUID ID with ID provided')]
+    #[TestDox('insert() succeeds for object with auto UUID ID with ID provided')]
     public function testInsertSucceedsForObjectWithAutoUuidIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::UUID;
@@ -219,15 +228,15 @@ class DocumentTest extends TestCase
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             $uuid = AutoId::generateUUID();
             Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 14)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals($uuid, $doc->id, 'The ID should not have been changed');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 14)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals($uuid, $doc->value->id, 'The ID should not have been changed');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto string ID not provided')]
+    #[TestDox('insert() succeeds for object with auto string ID not provided')]
     public function testInsertSucceedsForObjectWithAutoStringIdNotProvided(): void
     {
         Configuration::$autoId         = AutoId::RandomString;
@@ -235,57 +244,64 @@ class DocumentTest extends TestCase
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 55)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals(40, strlen($doc->id), 'The ID should have been auto-generated and had 40 characters');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 55)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals(40, strlen($doc->value->id),
+                'The ID should have been auto-generated and had 40 characters');
         } finally {
             Configuration::$autoId         = AutoId::None;
             Configuration::$idStringLength = 16;
         }
     }
 
-    #[TestDox('Insert succeeds for object with auto string ID with ID provided')]
+    #[TestDox('insert() succeeds for object with auto string ID with ID provided')]
     public function testInsertSucceedsForObjectWithAutoStringIdWithIdProvided(): void
     {
         Configuration::$autoId = AutoId::RandomString;
         try {
             Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
             Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3));
-            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 3)], TestDocument::class);
-            $this->assertNotFalse($doc, 'There should have been a document returned');
-            $this->assertEquals('my-key', $doc->id, 'The ID should not have been changed');
+            $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
+            $this->assertTrue($doc->isSome, 'There should have been a document returned');
+            $this->assertEquals('my-key', $doc->value->id, 'The ID should not have been changed');
         } finally {
             Configuration::$autoId = AutoId::None;
         }
     }
 
+    #[TestDox('insert() fails for duplicate key')]
     public function testInsertFailsForDuplicateKey(): void
     {
         $this->expectException(DocumentException::class);
         Document::insert(ThrowawayDb::TABLE, new TestDocument('one'));
     }
 
+    #[TestDox('save() succeeds when a document is inserted')]
     public function testSaveSucceedsWhenADocumentIsInserted(): void
     {
         Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b')));
         $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
     }
 
+    #[TestDox('save() succeeds when a document is updated')]
     public function testSaveSucceedsWhenADocumentIsUpdated(): void
     {
         Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
+        $doc = $tryDoc->value;
         $this->assertEquals(44, $doc->num_value, 'The numeric value was not updated');
         $this->assertNull($doc->sub, 'The sub-document should have been null');
     }
 
+    #[TestDox('update() succeeds when replacing a document')]
     public function testUpdateSucceedsWhenReplacingADocument(): void
     {
         Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z')));
-        $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
+        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
+        $doc = $tryDoc->value;
         $this->assertEquals('howdy', $doc->value, 'The value was incorrect');
         $this->assertEquals(8, $doc->num_value, 'The numeric value was incorrect');
         $this->assertNotNull($doc->sub, 'The sub-document should not have been null');
@@ -293,10 +309,11 @@ class DocumentTest extends TestCase
         $this->assertEquals('z', $doc->sub->bar, 'The sub-document bar property was incorrect');
     }
 
+    #[TestDox('update() succeeds when no document is replaced')]
     public function testUpdateSucceedsWhenNoDocumentIsReplaced(): void
     {
         Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200'));
         $doc = Find::byId(ThrowawayDb::TABLE, 'two-hundred', TestDocument::class);
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 }

tests/integration/sqlite/ExistsTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
@@ -27,38 +33,41 @@ class ExistsTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('By ID succeeds when a document exists')]
+    #[TestDox('byId() succeeds when a document exists')]
     public function testByIdSucceedsWhenADocumentExists(): void
     {
         $this->assertTrue(Exists::byId(ThrowawayDb::TABLE, 'three'), 'There should have been an existing document');
     }
 
-    #[TestDox('By ID succeeds when a document does not exist')]
+    #[TestDox('byId() succeeds when a document does not exist')]
     public function testByIdSucceedsWhenADocumentDoesNotExist(): void
     {
         $this->assertFalse(Exists::byId(ThrowawayDb::TABLE, 'seven'),
             'There should not have been an existing document');
     }
 
+    #[TestDox('byFields() succeeds when documents exist')]
     public function testByFieldsSucceedsWhenDocumentsExist(): void
     {
-        $this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 10)]),
+        $this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 10)]),
             'There should have been existing documents');
     }
 
+    #[TestDox('byFields() succeeds when no matching documents exist')]
     public function testByFieldsSucceedsWhenNoMatchingDocumentsExist(): void
     {
-        $this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::LT('nothing', 'none')]),
+        $this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::less('nothing', 'none')]),
             'There should not have been any existing documents');
     }
 
+    #[TestDox('byContains() fails')]
     public function testByContainsFails(): void
     {
         $this->expectException(DocumentException::class);
         Exists::byContains('', []);
     }
 
-    #[TestDox('By JSON Path fails')]
+    #[TestDox('byJsonPath() fails')]
     public function testByJsonPathFails(): void
     {
         $this->expectException(DocumentException::class);

tests/integration/sqlite/FindTest.php

@@ -1,10 +1,17 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
-use BitBadger\PDODocument\{Custom, Document, DocumentException, Field, Find};
+use BitBadger\PDODocument\{Custom, Delete, Document, DocumentException, Field, FieldMatch, Find};
 use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
+use Test\Integration\ArrayDocument;
 use Test\Integration\TestDocument;
 
 /**
@@ -28,103 +35,202 @@ class FindTest extends TestCase
         parent::tearDown();
     }
 
+    #[TestDox('all() succeeds when there is data')]
     public function testAllSucceedsWhenThereIsData(): void
     {
         $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
         $count = 0;
-        foreach ($docs->items() as $ignored) $count++;
+        foreach ($docs->items as $ignored) $count++;
         $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
     }
 
+    #[TestDox('all() succeeds when ordering data ascending')]
+    public function testAllSucceedsWhenOrderingDataAscending(): void
+    {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['five', 'four', 'one', 'three', 'two'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('all() succeeds when ordering data descending')]
+    public function testAllSucceedsWhenOrderingDataDescending(): void
+    {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id DESC')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['two', 'three', 'one', 'four', 'five'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('all() succeeds when ordering data numerically')]
+    public function testAllSucceedsWhenOrderingDataNumerically(): void
+    {
+        $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class,
+            [Field::named('sub.foo NULLS LAST'), Field::named('n:num_value')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['two', 'four', 'one', 'three', 'five'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('all() succeeds when there is no data')]
     public function testAllSucceedsWhenThereIsNoData(): void
     {
         Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
         $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
+        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
     }
 
-    #[TestDox('By ID succeeds when a document is found')]
+    #[TestDox('byId() succeeds when a document is found')]
     public function testByIdSucceedsWhenADocumentIsFound(): void
     {
         $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertEquals('two', $doc->id, 'An incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('two', $doc->value->id, 'An incorrect document was returned');
     }
 
-    #[TestDox('By ID succeeds when a document is found with numeric ID')]
+    #[TestDox('byId() succeeds when a document is found with numeric ID')]
     public function testByIdSucceedsWhenADocumentIsFoundWithNumericId(): void
     {
         Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']);
         $doc = Find::byId(ThrowawayDb::TABLE, 18, TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertEquals('18', $doc->id, 'An incorrect document was returned');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('18', $doc->value->id, 'An incorrect document was returned');
     }
 
-    #[TestDox('By ID succeeds when a document is not found')]
+    #[TestDox('byId() succeeds when a document is not found')]
     public function testByIdSucceedsWhenADocumentIsNotFound(): void
     {
         $doc = Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class);
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 
+    #[TestDox('byFields() succeeds when documents are found')]
     public function testByFieldsSucceedsWhenDocumentsAreFound(): void
     {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::GT('num_value', 15)], TestDocument::class);
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('value', ['blue', 'purple']), Field::exists('sub')],
+            TestDocument::class, FieldMatch::All);
         $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
         $count = 0;
-        foreach ($docs->items() as $ignored) $count++;
+        foreach ($docs->items as $ignored) $count++;
+        $this->assertEquals(1, $count, 'There should have been 1 document in the list');
+    }
+
+    #[TestDox('byFields() succeeds when documents are found and ordered')]
+    public function testByFieldsSucceedsWhenDocumentsAreFoundAndOrdered(): void
+    {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], TestDocument::class,
+            FieldMatch::All, [Field::named('id')]);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
+        $this->assertEquals(['five', 'four'], $ids, 'The documents were not ordered correctly');
+    }
+
+    #[TestDox('byFields() succeeds when documents are found using IN with numeric field')]
+    public function testByFieldsSucceedsWhenDocumentsAreFoundUsingInWithNumericField(): void
+    {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('num_value', [2, 4, 6, 8])], TestDocument::class);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
+        $this->assertEquals(1, $count, 'There should have been 1 document in the list');
+    }
+
+    #[TestDox('byFields() succeeds when no documents are found')]
+    public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void
+    {
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::greater('num_value', 100)], TestDocument::class);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
+    }
+
+    #[TestDox('byFields() succeeds for inArray when matching documents exist')]
+    public function testByFieldsSucceedsForInArrayWhenMatchingDocumentsExist(): void
+    {
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
+        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['c'])],
+            ArrayDocument::class);
+        $this->assertNotNull($docs, 'There should have been a document list returned');
+        $this->assertTrue($docs->hasItems, 'There should have been documents in the list');
+        $count = 0;
+        foreach ($docs->items as $ignored) $count++;
         $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
     }
 
-    public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void
+    #[TestDox('byFields() succeeds for inArray when no matching documents exist')]
+    public function testByFieldsSucceedsForInArrayWhenNoMatchingDocumentsExist(): void
     {
-        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::GT('num_value', 100)], TestDocument::class);
+        Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
+        foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
+        $docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['j'])],
+            ArrayDocument::class);
         $this->assertNotNull($docs, 'There should have been a document list returned');
-        $this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
+        $this->assertFalse($docs->hasItems, 'There should have been no documents in the list');
     }
 
+    #[TestDox('byContains() fails')]
     public function testByContainsFails(): void
     {
         $this->expectException(DocumentException::class);
         Find::byContains('', [], TestDocument::class);
     }
 
-    #[TestDox('By JSON Path fails')]
+    #[TestDox('byJsonPath() fails')]
     public function testByJsonPathFails(): void
     {
         $this->expectException(DocumentException::class);
         Find::byJsonPath('', '', TestDocument::class);
     }
 
+    #[TestDox('firstByFields() succeeds when a document is found')]
     public function testFirstByFieldsSucceedsWhenADocumentIsFound(): void
     {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'another')], TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertEquals('two', $doc->id, 'The incorrect document was returned');
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'another')], TestDocument::class);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('two', $doc->value->id, 'The incorrect document was returned');
     }
 
+    #[TestDox('firstByFields() succeeds when multiple documents are found')]
     public function testFirstByFieldsSucceedsWhenMultipleDocumentsAreFound(): void
     {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('sub.foo', 'green')], TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertContains($doc->id, ['two', 'four'], 'An incorrect document was returned');
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertContains($doc->value->id, ['two', 'four'], 'An incorrect document was returned');
     }
 
+    #[TestDox('firstByFields() succeeds when multiple ordered documents are found')]
+    public function testFirstByFieldsSucceedsWhenMultipleOrderedDocumentsAreFound(): void
+    {
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class,
+            orderBy: [Field::named('n:num_value DESC')]);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals('four', $doc->value->id, 'The incorrect document was returned');
+    }
+
+    #[TestDox('firstByFields() succeeds when a document is not found')]
     public function testFirstByFieldsSucceedsWhenADocumentIsNotFound(): void
     {
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'absent')], TestDocument::class);
-        $this->assertFalse($doc, 'There should not have been a document returned');
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'absent')], TestDocument::class);
+        $this->assertTrue($doc->isNone, 'There should not have been a document returned');
     }
 
+    #[TestDox('firstByContains() fails')]
     public function testFirstByContainsFails(): void
     {
         $this->expectException(DocumentException::class);
         Find::firstByContains('', [], TestDocument::class);
     }
 
-    #[TestDox('First by JSON Path fails')]
+    #[TestDox('firstByJsonPath() fails')]
     public function testFirstByJsonPathFails(): void
     {
         $this->expectException(DocumentException::class);

tests/integration/sqlite/PatchTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
@@ -28,42 +34,45 @@ class PatchTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('By ID succeeds when a document is updated')]
+    #[TestDox('byId() succeeds when a document is updated')]
     public function testByIdSucceedsWhenADocumentIsUpdated(): void
     {
         Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]);
         $doc = Find::byId(ThrowawayDb::TABLE, 'one', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertEquals(44, $doc->num_value, 'The updated document is not correct');
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertEquals(44, $doc->value->num_value, 'The updated document is not correct');
     }
 
-    #[TestDox('By ID succeeds when no document is updated')]
+    #[TestDox('byId() succeeds when no document is updated')]
     public function testByIdSucceedsWhenNoDocumentIsUpdated(): void
     {
         Patch::byId(ThrowawayDb::TABLE, 'forty-seven', ['foo' => 'green']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byFields() succeeds when a document is updated')]
     public function testByFieldsSucceedsWhenADocumentIsUpdated(): void
     {
-        Patch::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'purple')], ['num_value' => 77]);
-        $after = Count::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 77)]);
+        Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], ['num_value' => 77]);
+        $after = Count::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 77)]);
         $this->assertEquals(2, $after, 'There should have been 2 documents updated');
     }
 
+    #[TestDox('byFields() succeeds when no document is updated')]
     public function testByFieldsSucceedsWhenNoDocumentIsUpdated(): void
     {
-        Patch::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'burgundy')], ['foo' => 'green']);
+        Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'burgundy')], ['foo' => 'green']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byContains() fails')]
     public function testByContainsFails(): void
     {
         $this->expectException(DocumentException::class);
         Patch::byContains('', [], []);
     }
 
-    #[TestDox('By JSON Path fails')]
+    #[TestDox('byJsonPath() fails')]
     public function testByJsonPathFails(): void
     {
         $this->expectException(DocumentException::class);

tests/integration/sqlite/RemoveFieldsTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
@@ -28,57 +34,62 @@ class RemoveFieldsTest extends TestCase
         parent::tearDown();
     }
 
-    #[TestDox('By ID succeeds when fields are removed')]
+    #[TestDox('byId() succeeds when fields are removed')]
     public function testByIdSucceedsWhenFieldsAreRemoved(): void
     {
         RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']);
-        $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
+        $tryDoc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
+        $this->assertTrue($tryDoc->isSome, 'There should have been a document returned');
+        $doc = $tryDoc->value;
         $this->assertEquals('', $doc->value, 'Value should have been blank (its default value)');
         $this->assertNull($doc->sub, 'Sub-document should have been null');
     }
 
-    #[TestDox('By ID succeeds when a field is not removed')]
+    #[TestDox('byId() succeeds when a field is not removed')]
     public function testByIdSucceedsWhenAFieldIsNotRemoved(): void
     {
         RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
-    #[TestDox('By ID succeeds when no document is matched')]
+    #[TestDox('byId() succeeds when no document is matched')]
     public function testByIdSucceedsWhenNoDocumentIsMatched(): void
     {
         RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byFields() succeeds when a field is removed')]
     public function testByFieldsSucceedsWhenAFieldIsRemoved(): void
     {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], ['sub']);
-        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], TestDocument::class);
-        $this->assertNotFalse($doc, 'There should have been a document returned');
-        $this->assertNull($doc->sub, 'Sub-document should have been null');
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['sub']);
+        $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], TestDocument::class);
+        $this->assertTrue($doc->isSome, 'There should have been a document returned');
+        $this->assertNull($doc->value->sub, 'Sub-document should have been null');
     }
 
+    #[TestDox('byFields() succeeds when a field is not removed')]
     public function testByFieldsSucceedsWhenAFieldIsNotRemoved(): void
     {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], ['nada']);
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['nada']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byFields() succeeds when no document is matched')]
     public function testByFieldsSucceedsWhenNoDocumentIsMatched(): void
     {
-        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::NE('missing', 'nope')], ['value']);
+        RemoveFields::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')], ['value']);
         $this->assertTrue(true, 'The above not throwing an exception is the test');
     }
 
+    #[TestDox('byContains() fails')]
     public function testByContainsFails(): void
     {
         $this->expectException(DocumentException::class);
         RemoveFields::byContains('', [], []);
     }
 
-    #[TestDox('By JSON Path fails')]
+    #[TestDox('byJsonPath() fails')]
     public function testByJsonPathFails(): void
     {
         $this->expectException(DocumentException::class);

tests/integration/sqlite/ThrowawayDb.php

@@ -1,8 +1,15 @@
 <?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ * @see https://github.com/Zaid-Ajaj/ThrowawayDb The origin concept
+ */
+
+declare(strict_types=1);
 
 namespace Test\Integration\SQLite;
 
-use BitBadger\PDODocument\{AutoId, Configuration, Definition, Document, DocumentException, Mode};
+use BitBadger\PDODocument\{AutoId, Configuration, Definition, Document, DocumentException};
 use Random\RandomException;
 use Test\Integration\{SubDocument, TestDocument};
 
@@ -12,7 +19,7 @@ use Test\Integration\{SubDocument, TestDocument};
 class ThrowawayDb
 {
     /** @var string The table used for document manipulation */
-    public const TABLE = "test_table";
+    public const TABLE = 'test_table';
 
     /**
      * Create a throwaway SQLite database
@@ -24,8 +31,7 @@ class ThrowawayDb
     public static function create(bool $withData = true): string
     {
         $fileName = sprintf('throwaway-%s.db', AutoId::generateRandom(10));
-        Configuration::$pdoDSN = "sqlite:./$fileName";
-        Configuration::$mode   = Mode::SQLite;
+        Configuration::useDSN("sqlite:./$fileName");
         Configuration::resetPDO();
 
         if ($withData) {

tests/unit/ConfigurationTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit;
 
@@ -12,14 +18,14 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('Configuration (Unit tests)')]
 class ConfigurationTest extends TestCase
 {
-    #[TestDox('ID field default succeeds')]
+    #[TestDox('id default succeeds')]
     public function testIdFieldDefaultSucceeds(): void
     {
         $this->assertEquals('id', Configuration::$idField, 'Default ID field should be "id"');
     }
 
-    #[TestDox('ID field change succeeds')]
-    public function testIdFieldChangeSucceeds()
+    #[TestDox('id change succeeds')]
+    public function testIdFieldChangeSucceeds(): void
     {
         try {
             Configuration::$idField = 'EyeDee';
@@ -30,23 +36,23 @@ class ConfigurationTest extends TestCase
         }
     }
 
-    #[TestDox('Auto ID default succeeds')]
+    #[TestDox('autoId default succeeds')]
     public function testAutoIdDefaultSucceeds(): void
     {
         $this->assertEquals(AutoId::None, Configuration::$autoId, 'Auto ID should default to None');
     }
 
-    #[TestDox('ID string length default succeeds')]
+    #[TestDox('idStringLength default succeeds')]
     public function testIdStringLengthDefaultSucceeds(): void
     {
         $this->assertEquals(16, Configuration::$idStringLength, 'ID string length should default to 16');
     }
 
-    #[TestDox("Db conn fails when no DSN specified")]
+    #[TestDox("dbConn() fails when no DSN specified")]
     public function testDbConnFailsWhenNoDSNSpecified(): void
     {
         $this->expectException(DocumentException::class);
-        Configuration::$pdoDSN = '';
+        Configuration::useDSN('');
         Configuration::dbConn();
     }
 }

tests/unit/DocumentExceptionTest.php

@@ -1,4 +1,10 @@
 <?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit;
 
@@ -13,7 +19,7 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('Document Exception (Unit tests)')]
 class DocumentExceptionTest extends TestCase
 {
-    public function testConstructorSucceedsWithCodeAndPriorException()
+    public function testConstructorSucceedsWithCodeAndPriorException(): void
     {
         $priorEx = new Exception('Uh oh');
         $ex = new DocumentException('Test Exception', 17, $priorEx);
@@ -23,7 +29,7 @@ class DocumentExceptionTest extends TestCase
         $this->assertSame($priorEx, $ex->getPrevious(), 'Prior exception not filled properly');
     }
 
-    public function testConstructorSucceedsWithoutCodeAndPriorException()
+    public function testConstructorSucceedsWithoutCodeAndPriorException(): void
     {
         $ex = new DocumentException('Oops');
         $this->assertNotNull($ex, 'The exception should not have been null');
@@ -32,14 +38,16 @@ class DocumentExceptionTest extends TestCase
         $this->assertNull($ex->getPrevious(), 'Prior exception should have been null');
     }
 
-    public function testToStringSucceedsWithoutCode()
+    #[TestDox('toString() succeeds without code')]
+    public function testToStringSucceedsWithoutCode(): void
     {
         $ex = new DocumentException('Test failure');
         $this->assertEquals("BitBadger\PDODocument\DocumentException: Test failure\n", "$ex",
             'toString not generated correctly');
     }
 
-    public function testToStringSucceedsWithCode()
+    #[TestDox('toString() succeeds with code')]
+    public function testToStringSucceedsWithCode(): void
     {
         $ex = new DocumentException('Oof', -6);
         $this->assertEquals("BitBadger\PDODocument\DocumentException: [-6] Oof\n", "$ex",

tests/unit/FieldMatchTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit;
 
@@ -12,13 +18,15 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('Field Match (Unit tests)')]
 class FieldMatchTest extends TestCase
 {
-    public function testToStringSucceedsForAll(): void
+    #[TestDox('toSQL() succeeds for All')]
+    public function testToSQLSucceedsForAll(): void
     {
-        $this->assertEquals('AND', FieldMatch::All->toString(), 'All should have returned AND');
+        $this->assertEquals('AND', FieldMatch::All->toSQL(), 'All should have returned AND');
     }
 
-    public function testToStringSucceedsForAny(): void
+    #[TestDox('toSQL() succeeds for Any')]
+    public function testToSQLSucceedsForAny(): void
     {
-        $this->assertEquals('OR', FieldMatch::Any->toString(), 'Any should have returned OR');
+        $this->assertEquals('OR', FieldMatch::Any->toSQL(), 'Any should have returned OR');
     }
 }

tests/unit/FieldTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit;
 
@@ -12,435 +18,665 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('Field (Unit tests)')]
 class FieldTest extends TestCase
 {
-    #[TestDox('Append parameter succeeds for EX')]
-    public function testAppendParameterSucceedsForEX(): void
+    #[TestDox('appendParameter() succeeds for exists')]
+    public function testAppendParameterSucceedsForExists(): void
     {
-        $this->assertEquals([], Field::EX('exists')->appendParameter([]), 'EX should not have appended a parameter');
+        $this->assertEquals([], Field::exists('exists')->appendParameter([]),
+            'exists should not have appended a parameter');
     }
 
-    #[TestDox('Append parameter succeeds for NEX')]
-    public function testAppendParameterSucceedsForNEX(): void
+    #[TestDox('appendParameter() succeeds for notExists')]
+    public function testAppendParameterSucceedsForNotExists(): void
     {
-        $this->assertEquals([], Field::NEX('absent')->appendParameter([]), 'NEX should not have appended a parameter');
+        $this->assertEquals([], Field::notExists('absent')->appendParameter([]),
+            'notExists should not have appended a parameter');
     }
 
-    #[TestDox('Append parameter succeeds for BT')]
-    public function testAppendParameterSucceedsForBT(): void
+    #[TestDox('appendParameter() succeeds for between')]
+    public function testAppendParameterSucceedsForBetween(): void
     {
-        $this->assertEquals(['@nummin' => 5, '@nummax' => 9], Field::BT('exists', 5, 9, '@num')->appendParameter([]),
-            'BT should have appended min and max parameters');
+        $this->assertEquals(['@nummin' => 5, '@nummax' => 9],
+            Field::between('exists', 5, 9, '@num')->appendParameter([]),
+            'Between should have appended min and max parameters');
     }
 
+    #[TestDox('appendParameter() succeeds for in')]
+    public function testAppendParameterSucceedsForIn(): void
+    {
+        $this->assertEquals([':val_0' => 'test', ':val_1' => 'unit', ':val_2' => 'great'],
+            Field::in('it', ['test', 'unit', 'great'], ':val')->appendParameter([]),
+            'In should have appended 3 parameters for the input values');
+    }
+
+    #[TestDox('appendParameter() succeeds for inArray for PostgreSQL')]
+    public function testAppendParameterSucceedsForInArrayForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        try {
+            $this->assertEquals([':bit_0' => '2', ':bit_1' => '8', ':bit_2' => '64'],
+                Field::inArray('it', 'table', [2, 8, 64], ':bit')->appendParameter([]),
+                'InArray should have appended 3 string parameters for the input values');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('appendParameter() succeeds for inArray for SQLite')]
+    public function testAppendParameterSucceedsForInArrayForSQLite(): void
+    {
+        Configuration::overrideMode(Mode::SQLite);
+        try {
+            $this->assertEquals([':bit_0' => 2, ':bit_1' => 8, ':bit_2' => 64],
+                Field::inArray('it', 'table', [2, 8, 64], ':bit')->appendParameter([]),
+                'InArray should have appended 3 parameters for the input values');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('appendParameter() succeeds for others')]
     public function testAppendParameterSucceedsForOthers(): void
     {
-        $this->assertEquals(['@test' => 33], Field::EQ('the_field', 33, '@test')->appendParameter([]),
+        $this->assertEquals(['@test' => 33], Field::equal('the_field', 33, '@test')->appendParameter([]),
             'Field parameter not returned correctly');
     }
 
-    #[TestDox('To where succeeds for EX without qualifier for PostgreSQL')]
-    public function testToWhereSucceedsForEXWithoutQualifierForPostgreSQL(): void
+    #[TestDox('path() succeeds for simple SQL path for PostgreSQL')]
+    public function testPathSucceedsForSimpleSqlPathForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         try {
-            $this->assertEquals("data->>'that_field' IS NOT NULL", Field::EX('that_field')->toWhere(),
-                'WHERE fragment not generated correctly');
+            $this->assertEquals("data->>'it'", Field::equal('it', 'that')->path(),
+                'SQL value path not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for EX without qualifier for SQLite')]
-    public function testToWhereSucceedsForEXWithoutQualifierForSQLite(): void
+    #[TestDox('path() succeeds for simple SQL path for SQLite')]
+    public function testPathSucceedsForSimpleSqlPathForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         try {
-            $this->assertEquals("data->>'that_field' IS NOT NULL", Field::EX('that_field')->toWhere(),
-                'WHERE fragment not generated correctly');
+            $this->assertEquals("data->>'top'", Field::equal('top', 'that')->path(),
+                'SQL value path not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for NEX without qualifier for PostgreSQL')]
-    public function testToWhereSucceedsForNEXWithoutQualifierForPostgreSQL(): void
+    #[TestDox('path() succeeds for nested SQL path for PostgreSQL')]
+    public function testPathSucceedsForNestedSqlPathForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         try {
-            $this->assertEquals("data->>'a_field' IS NULL", Field::NEX('a_field')->toWhere(),
-                'WHERE fragment not generated correctly');
+            $this->assertEquals("data#>>'{parts,to,the,path}'", Field::equal('parts.to.the.path', '')->path(),
+                'SQL value path not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for NEX without qualifier for SQLite')]
-    public function testToWhereSucceedsForNEXWithoutQualifierForSQLite(): void
+    #[TestDox('path() succeeds for nested SQL path for SQLite')]
+    public function testPathSucceedsForNestedSqlPathForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         try {
-            $this->assertEquals("data->>'a_field' IS NULL", Field::NEX('a_field')->toWhere(),
-                'WHERE fragment not generated correctly');
+            $this->assertEquals("data->'one'->'two'->>'three'", Field::equal('one.two.three', '')->path(),
+                'SQL value path not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for BT without qualifier for SQLite')]
-    public function testToWhereSucceedsForBTWithoutQualifierForSQLite(): void
+    #[TestDox('path() succeeds for simple JSON path for PostgreSQL')]
+    public function testPathSucceedsForSimpleJsonPathForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::PgSQL);
         try {
-            $this->assertEquals("data->>'age' BETWEEN @agemin AND @agemax", Field::BT('age', 13, 17, '@age')->toWhere(),
-                'WHERE fragment not generated correctly');
+            $this->assertEquals("data->'it'", Field::equal('it', 'that')->path(true),
+                'JSON value path not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for BT without qualifier for PostgreSQL with numeric range')]
-    public function testToWhereSucceedsForBTWithoutQualifierForPostgreSQLWithNumericRange(): void
+    #[TestDox('path() succeeds for simple JSON path for SQLite')]
+    public function testPathSucceedsForSimpleJsonPathForSQLite(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::SQLite);
+        try {
+            $this->assertEquals("data->'top'", Field::equal('top', 'that')->path(true),
+                'JSON value path not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('path() succeeds for nested JSON path for PostgreSQL')]
+    public function testPathSucceedsForNestedJsonPathForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        try {
+            $this->assertEquals("data#>'{parts,to,the,path}'", Field::equal('parts.to.the.path', '')->path(true),
+                'JSON value path not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('path() succeeds for nested JSON path for SQLite')]
+    public function testPathSucceedsForNestedJsonPathForSQLite(): void
+    {
+        Configuration::overrideMode(Mode::SQLite);
+        try {
+            $this->assertEquals("data->'one'->'two'->'three'", Field::equal('one.two.three', '')->path(true),
+                'SQL value path not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for exists without qualifier for PostgreSQL')]
+    public function testToWhereSucceedsForExistsWithoutQualifierForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        try {
+            $this->assertEquals("data->>'that_field' IS NOT NULL", Field::exists('that_field')->toWhere(),
+                'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for exists without qualifier for SQLite')]
+    public function testToWhereSucceedsForExistsWithoutQualifierForSQLite(): void
+    {
+        Configuration::overrideMode(Mode::SQLite);
+        try {
+            $this->assertEquals("data->>'that_field' IS NOT NULL", Field::exists('that_field')->toWhere(),
+                'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for notExists without qualifier for PostgreSQL')]
+    public function testToWhereSucceedsForNotExistsWithoutQualifierForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        try {
+            $this->assertEquals("data->>'a_field' IS NULL", Field::notExists('a_field')->toWhere(),
+                'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for notExists without qualifier for SQLite')]
+    public function testToWhereSucceedsForNotExistsWithoutQualifierForSQLite(): void
+    {
+        Configuration::overrideMode(Mode::SQLite);
+        try {
+            $this->assertEquals("data->>'a_field' IS NULL", Field::notExists('a_field')->toWhere(),
+                'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for between without qualifier for SQLite')]
+    public function testToWhereSucceedsForBetweenWithoutQualifierForSQLite(): void
+    {
+        Configuration::overrideMode(Mode::SQLite);
+        try {
+            $this->assertEquals("data->>'age' BETWEEN @agemin AND @agemax",
+                Field::between('age', 13, 17, '@age')->toWhere(), 'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for between without qualifier for PostgreSQL with numeric range')]
+    public function testToWhereSucceedsForBetweenWithoutQualifierForPostgreSQLWithNumericRange(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
         try {
             $this->assertEquals("(data->>'age')::numeric BETWEEN @agemin AND @agemax",
-                Field::BT('age', 13, 17, '@age')->toWhere(), 'WHERE fragment not generated correctly');
+                Field::between('age', 13, 17, '@age')->toWhere(), 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for BT without qualifier for PostgreSQL with non-numeric range')]
-    public function testToWhereSucceedsForBTWithoutQualifierForPostgreSQLWithNonNumericRange(): void
+    #[TestDox('toWhere() succeeds for between without qualifier for PostgreSQL with non-numeric range')]
+    public function testToWhereSucceedsForBetweenWithoutQualifierForPostgreSQLWithNonNumericRange(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         try {
             $this->assertEquals("data->>'city' BETWEEN :citymin AND :citymax",
-                Field::BT('city', 'Atlanta', 'Chicago', ':city')->toWhere(), 'WHERE fragment not generated correctly');
+                Field::between('city', 'Atlanta', 'Chicago', ':city')->toWhere(),
+                'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for BT with qualifier for SQLite')]
-    public function testToWhereSucceedsForBTWithQualifierForSQLite(): void
+    #[TestDox('toWhere() succeeds for between with qualifier for SQLite')]
+    public function testToWhereSucceedsForBetweenWithQualifierForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         try {
-            $field = Field::BT('age', 13, 17, '@age');
+            $field = Field::between('age', 13, 17, '@age');
             $field->qualifier = 'me';
             $this->assertEquals("me.data->>'age' BETWEEN @agemin AND @agemax", $field->toWhere(),
                 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for BT with qualifier for PostgreSQL with numeric range')]
-    public function testToWhereSucceedsForBTWithQualifierForPostgreSQLWithNumericRange(): void
+    #[TestDox('toWhere() succeeds for between with qualifier for PostgreSQL with numeric range')]
+    public function testToWhereSucceedsForBetweenWithQualifierForPostgreSQLWithNumericRange(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         try {
-            $field = Field::BT('age', 13, 17, '@age');
+            $field = Field::between('age', 13, 17, '@age');
             $field->qualifier = 'me';
             $this->assertEquals("(me.data->>'age')::numeric BETWEEN @agemin AND @agemax", $field->toWhere(),
                 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for BT with qualifier for PostgreSQL with non-numeric range')]
-    public function testToWhereSucceedsForBTWithQualifierForPostgreSQLWithNonNumericRange(): void
+    #[TestDox('toWhere() succeeds for between with qualifier for PostgreSQL with non-numeric range')]
+    public function testToWhereSucceedsForBetweenWithQualifierForPostgreSQLWithNonNumericRange(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         try {
-            $field = Field::BT('city', 'Atlanta', 'Chicago', ':city');
+            $field = Field::between('city', 'Atlanta', 'Chicago', ':city');
             $field->qualifier = 'me';
             $this->assertEquals("me.data->>'city' BETWEEN :citymin AND :citymax", $field->toWhere(),
                 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for others without qualifier for PostgreSQL')]
+    #[TestDox('toWhere() succeeds for in for PostgreSQL with non-numeric values')]
+    public function testToWhereSucceedsForInForPostgreSQLWithNonNumericValues(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        try {
+            $field = Field::in('test', ['Atlanta', 'Chicago'], ':city');
+            $this->assertEquals("data->>'test' IN (:city_0, :city_1)", $field->toWhere(),
+                'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for in for PostgreSQL with numeric values')]
+    public function testToWhereSucceedsForInForPostgreSQLWithNumericValues(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        try {
+            $field = Field::in('even', [2, 4, 6], ':nbr');
+            $this->assertEquals("(data->>'even')::numeric IN (:nbr_0, :nbr_1, :nbr_2)", $field->toWhere(),
+                'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for in for SQLite')]
+    public function testToWhereSucceedsForInForSQLite(): void
+    {
+        Configuration::overrideMode(Mode::SQLite);
+        try {
+            $field = Field::in('test', ['Atlanta', 'Chicago'], ':city');
+            $this->assertEquals("data->>'test' IN (:city_0, :city_1)", $field->toWhere(),
+                'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for inArray for PostgreSQL')]
+    public function testToWhereSucceedsForInArrayForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        try {
+            $field = Field::inArray('even', 'tbl', [2, 4, 6, 8], ':it');
+            $this->assertEquals("data->'even' ??| ARRAY[:it_0, :it_1, :it_2, :it_3]", $field->toWhere(),
+                'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for inArray for SQLite')]
+    public function testToWhereSucceedsForInArrayForSQLite(): void
+    {
+        Configuration::overrideMode(Mode::SQLite);
+        try {
+            $field = Field::inArray('test', 'tbl', ['Atlanta', 'Chicago'], ':city');
+            $this->assertEquals(
+                "EXISTS (SELECT 1 FROM json_each(tbl.data, '\$.test') WHERE value IN (:city_0, :city_1))",
+                $field->toWhere(), 'WHERE fragment not generated correctly');
+        } finally {
+            Configuration::overrideMode(null);
+        }
+    }
+
+    #[TestDox('toWhere() succeeds for others without qualifier for PostgreSQL')]
     public function testToWhereSucceedsForOthersWithoutQualifierForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         try {
-            $this->assertEquals("data->>'some_field' = @value", Field::EQ('some_field', '', '@value')->toWhere(),
+            $this->assertEquals("data->>'some_field' = @value", Field::equal('some_field', '', '@value')->toWhere(),
                 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds for others without qualifier for SQLite')]
+    #[TestDox('toWhere() succeeds for others without qualifier for SQLite')]
     public function testToWhereSucceedsForOthersWithoutQualifierForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         try {
-            $this->assertEquals("data->>'some_field' = @value", Field::EQ('some_field', '', '@value')->toWhere(),
+            $this->assertEquals("data->>'some_field' = @value", Field::equal('some_field', '', '@value')->toWhere(),
                 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds with qualifier no parameter for PostgreSQL')]
+    #[TestDox('toWhere() succeeds with qualifier no parameter for PostgreSQL')]
     public function testToWhereSucceedsWithQualifierNoParameterForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         try {
-            $field = Field::EX('no_field');
+            $field = Field::exists('no_field');
             $field->qualifier = 'test';
             $this->assertEquals("test.data->>'no_field' IS NOT NULL", $field->toWhere(),
                 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds with qualifier no parameter for SQLite')]
+    #[TestDox('toWhere() succeeds with qualifier no parameter for SQLite')]
     public function testToWhereSucceedsWithQualifierNoParameterForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         try {
-            $field = Field::EX('no_field');
+            $field = Field::exists('no_field');
             $field->qualifier = 'test';
             $this->assertEquals("test.data->>'no_field' IS NOT NULL", $field->toWhere(),
                 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds with qualifier and parameter for PostgreSQL')]
+    #[TestDox('toWhere() succeeds with qualifier and parameter for PostgreSQL')]
     public function testToWhereSucceedsWithQualifierAndParameterForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         try {
-            $field = Field::LE('le_field', 18, '@it');
+            $field = Field::lessOrEqual('le_field', 18, '@it');
             $field->qualifier = 'q';
             $this->assertEquals("(q.data->>'le_field')::numeric <= @it", $field->toWhere(),
                 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds with qualifier and parameter for SQLite')]
+    #[TestDox('toWhere() succeeds with qualifier and parameter for SQLite')]
     public function testToWhereSucceedsWithQualifierAndParameterForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         try {
-            $field = Field::LE('le_field', 18, '@it');
+            $field = Field::lessOrEqual('le_field', 18, '@it');
             $field->qualifier = 'q';
             $this->assertEquals("q.data->>'le_field' <= @it", $field->toWhere(),
                 'WHERE fragment not generated correctly');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('To where succeeds with sub-document for PostgreSQL')]
-    public function testToWhereSucceedsWithSubDocumentForPostgreSQL(): void
+    #[TestDox('equal() succeeds without parameter')]
+    public function testEqualSucceedsWithoutParameter(): void
     {
-        Configuration::$mode = Mode::PgSQL;
-        try {
-            $field = Field::EQ('sub.foo.bar', 22, '@it');
-            $this->assertEquals("(data#>>'{sub,foo,bar}')::numeric = @it", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
-    }
-
-    #[TestDox('To where succeeds with sub-document for SQLite')]
-    public function testToWhereSucceedsWithSubDocumentForSQLite(): void
-    {
-        Configuration::$mode = Mode::SQLite;
-        try {
-            $field = Field::EQ('sub.foo.bar', 22, '@it');
-            $this->assertEquals("data->>'sub'->>'foo'->>'bar' = @it", $field->toWhere(),
-                'WHERE fragment not generated correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
-    }
-
-    #[TestDox('EQ succeeds without parameter')]
-    public function testEQSucceedsWithoutParameter(): void
-    {
-        $field = Field::EQ('my_test', 9);
+        $field = Field::equal('my_test', 9);
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('my_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::EQ, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::Equal, $field->op, 'Operation not filled correctly');
         $this->assertEquals(9, $field->value, 'Value not filled correctly');
         $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
     }
 
-    #[TestDox('EQ succeeds with parameter')]
-    public function testEQSucceedsWithParameter(): void
+    #[TestDox('equal() succeeds with parameter')]
+    public function testEqualSucceedsWithParameter(): void
     {
-        $field = Field::EQ('another_test', 'turkey', '@test');
+        $field = Field::equal('another_test', 'turkey', '@test');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('another_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::EQ, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::Equal, $field->op, 'Operation not filled correctly');
         $this->assertEquals('turkey', $field->value, 'Value not filled correctly');
         $this->assertEquals('@test', $field->paramName, 'Parameter name not filled correctly');
     }
 
-    #[TestDox('GT succeeds without parameter')]
-    public function testGTSucceedsWithoutParameter(): void
+    #[TestDox('greater() succeeds without parameter')]
+    public function testGreaterSucceedsWithoutParameter(): void
     {
-        $field = Field::GT('your_test', 4);
+        $field = Field::greater('your_test', 4);
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('your_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::GT, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::Greater, $field->op, 'Operation not filled correctly');
         $this->assertEquals(4, $field->value, 'Value not filled correctly');
         $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
     }
 
-    #[TestDox('GT succeeds with parameter')]
-    public function testGTSucceedsWithParameter(): void
+    #[TestDox('greater() succeeds with parameter')]
+    public function testGreaterSucceedsWithParameter(): void
     {
-        $field = Field::GT('more_test', 'chicken', '@value');
+        $field = Field::greater('more_test', 'chicken', '@value');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('more_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::GT, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::Greater, $field->op, 'Operation not filled correctly');
         $this->assertEquals('chicken', $field->value, 'Value not filled correctly');
         $this->assertEquals('@value', $field->paramName, 'Parameter name not filled correctly');
     }
 
-    #[TestDox('GE succeeds without parameter')]
-    public function testGESucceedsWithoutParameter(): void
+    #[TestDox('greaterOrEqual() succeeds without parameter')]
+    public function testGreaterOrEqualSucceedsWithoutParameter(): void
     {
-        $field = Field::GE('their_test', 6);
+        $field = Field::greaterOrEqual('their_test', 6);
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('their_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::GE, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::GreaterOrEqual, $field->op, 'Operation not filled correctly');
         $this->assertEquals(6, $field->value, 'Value not filled correctly');
         $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
     }
 
-    #[TestDox('GE succeeds with parameter')]
-    public function testGESucceedsWithParameter(): void
+    #[TestDox('greaterOrEqual() succeeds with parameter')]
+    public function testGreaterOrEqualSucceedsWithParameter(): void
     {
-        $field = Field::GE('greater_test', 'poultry', '@cluck');
+        $field = Field::greaterOrEqual('greater_test', 'poultry', '@cluck');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('greater_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::GE, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::GreaterOrEqual, $field->op, 'Operation not filled correctly');
         $this->assertEquals('poultry', $field->value, 'Value not filled correctly');
         $this->assertEquals('@cluck', $field->paramName, 'Parameter name not filled correctly');
     }
 
-    #[TestDox('LT succeeds without parameter')]
-    public function testLTSucceedsWithoutParameter(): void
+    #[TestDox('less() succeeds without parameter')]
+    public function testLessSucceedsWithoutParameter(): void
     {
-        $field = Field::LT('z', 32);
+        $field = Field::less('z', 32);
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('z', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::LT, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::Less, $field->op, 'Operation not filled correctly');
         $this->assertEquals(32, $field->value, 'Value not filled correctly');
         $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
     }
 
-    #[TestDox('LT succeeds with parameter')]
-    public function testLTSucceedsWithParameter(): void
+    #[TestDox('less() succeeds with parameter')]
+    public function testLessSucceedsWithParameter(): void
     {
-        $field = Field::LT('additional_test', 'fowl', '@boo');
+        $field = Field::less('additional_test', 'fowl', '@boo');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('additional_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::LT, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::Less, $field->op, 'Operation not filled correctly');
         $this->assertEquals('fowl', $field->value, 'Value not filled correctly');
         $this->assertEquals('@boo', $field->paramName, 'Parameter name not filled correctly');
     }
 
-    #[TestDox('LE succeeds without parameter')]
-    public function testLESucceedsWithoutParameter(): void
+    #[TestDox('lessOrEqual() succeeds without parameter')]
+    public function testLessOrEqualSucceedsWithoutParameter(): void
     {
-        $field = Field::LE('g', 87);
+        $field = Field::lessOrEqual('g', 87);
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('g', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::LE, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::LessOrEqual, $field->op, 'Operation not filled correctly');
         $this->assertEquals(87, $field->value, 'Value not filled correctly');
         $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
     }
 
-    #[TestDox('LE succeeds with parameter')]
-    public function testLESucceedsWithParameter(): void
+    #[TestDox('lessOrEqual() succeeds with parameter')]
+    public function testLessOrEqualSucceedsWithParameter(): void
     {
-        $field = Field::LE('lesser_test', 'hen', '@woo');
+        $field = Field::lessOrEqual('lesser_test', 'hen', '@woo');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('lesser_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::LE, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::LessOrEqual, $field->op, 'Operation not filled correctly');
         $this->assertEquals('hen', $field->value, 'Value not filled correctly');
         $this->assertEquals('@woo', $field->paramName, 'Parameter name not filled correctly');
     }
 
-    #[TestDox('NE succeeds without parameter')]
-    public function testNESucceedsWithoutParameter(): void
+    #[TestDox('notEqual() succeeds without parameter')]
+    public function testNotEqualSucceedsWithoutParameter(): void
     {
-        $field = Field::NE('j', 65);
+        $field = Field::notEqual('j', 65);
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('j', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::NE, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::NotEqual, $field->op, 'Operation not filled correctly');
         $this->assertEquals(65, $field->value, 'Value not filled correctly');
         $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
     }
 
-    #[TestDox('NE succeeds with parameter')]
-    public function testNESucceedsWithParameter(): void
+    #[TestDox('notEqual() succeeds with parameter')]
+    public function testNotEqualSucceedsWithParameter(): void
     {
-        $field = Field::NE('unequal_test', 'egg', '@zoo');
+        $field = Field::notEqual('unequal_test', 'egg', '@zoo');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('unequal_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::NE, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::NotEqual, $field->op, 'Operation not filled correctly');
         $this->assertEquals('egg', $field->value, 'Value not filled correctly');
         $this->assertEquals('@zoo', $field->paramName, 'Parameter name not filled correctly');
     }
 
-    #[TestDox('BT succeeds without parameter')]
-    public function testBTSucceedsWithoutParameter(): void
+    #[TestDox('between() succeeds without parameter')]
+    public function testBetweenSucceedsWithoutParameter(): void
     {
-        $field = Field::BT('k', 'alpha', 'zed');
+        $field = Field::between('k', 'alpha', 'zed');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('k', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::BT, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::Between, $field->op, 'Operation not filled correctly');
         $this->assertEquals(['alpha', 'zed'], $field->value, 'Value not filled correctly');
         $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
     }
 
-    #[TestDox('BT succeeds with parameter')]
-    public function testBTSucceedsWithParameter(): void
+    #[TestDox('between() succeeds with parameter')]
+    public function testBetweenSucceedsWithParameter(): void
     {
-        $field = Field::BT('between_test', 18, 49, '@count');
+        $field = Field::between('between_test', 18, 49, '@count');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('between_test', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::BT, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::Between, $field->op, 'Operation not filled correctly');
         $this->assertEquals([18, 49], $field->value, 'Value not filled correctly');
         $this->assertEquals('@count', $field->paramName, 'Parameter name not filled correctly');
     }
 
-    #[TestDox('EX succeeds')]
-    public function testEXSucceeds(): void
+    #[TestDox('in() succeeds without parameter')]
+    public function testInSucceedsWithoutParameter(): void
     {
-        $field = Field::EX('be_there');
+        $field = Field::in('test', [1, 2, 3]);
+        $this->assertNotNull($field, 'The field should not have been null');
+        $this->assertEquals('test', $field->fieldName, 'Field name not filled correctly');
+        $this->assertEquals(Op::In, $field->op, 'Operation not filled correctly');
+        $this->assertEquals([1, 2, 3], $field->value, 'Value not filled correctly');
+        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
+    }
+
+    #[TestDox('in() succeeds with parameter')]
+    public function testInSucceedsWithParameter(): void
+    {
+        $field = Field::in('unit', ['a', 'b'], '@inParam');
+        $this->assertNotNull($field, 'The field should not have been null');
+        $this->assertEquals('unit', $field->fieldName, 'Field name not filled correctly');
+        $this->assertEquals(Op::In, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(['a', 'b'], $field->value, 'Value not filled correctly');
+        $this->assertEquals('@inParam', $field->paramName, 'Parameter name not filled correctly');
+    }
+
+    #[TestDox('inArray() succeeds without parameter')]
+    public function testInArraySucceedsWithoutParameter(): void
+    {
+        $field = Field::inArray('test', 'tbl', [1, 2, 3]);
+        $this->assertNotNull($field, 'The field should not have been null');
+        $this->assertEquals('test', $field->fieldName, 'Field name not filled correctly');
+        $this->assertEquals(Op::InArray, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(['table' => 'tbl', 'values' => [1, 2, 3]], $field->value, 'Value not filled correctly');
+        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
+    }
+
+    #[TestDox('inArray() succeeds with parameter')]
+    public function testInArraySucceedsWithParameter(): void
+    {
+        $field = Field::inArray('unit', 'tab', ['a', 'b'], '@inAParam');
+        $this->assertNotNull($field, 'The field should not have been null');
+        $this->assertEquals('unit', $field->fieldName, 'Field name not filled correctly');
+        $this->assertEquals(Op::InArray, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(['table' => 'tab', 'values' => ['a', 'b']], $field->value, 'Value not filled correctly');
+        $this->assertEquals('@inAParam', $field->paramName, 'Parameter name not filled correctly');
+    }
+
+    #[TestDox('exists() succeeds')]
+    public function testExistsSucceeds(): void
+    {
+        $field = Field::exists('be_there');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('be_there', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::EX, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::Exists, $field->op, 'Operation not filled correctly');
         $this->assertEquals('', $field->value, 'Value should have been blank');
         $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
     }
 
-    #[TestDox('NEX succeeds')]
-    public function testNEXSucceeds(): void
+    #[TestDox('notExists() succeeds')]
+    public function testNotExistsSucceeds(): void
     {
-        $field = Field::NEX('be_absent');
+        $field = Field::notExists('be_absent');
         $this->assertNotNull($field, 'The field should not have been null');
         $this->assertEquals('be_absent', $field->fieldName, 'Field name not filled correctly');
-        $this->assertEquals(Op::NEX, $field->op, 'Operation not filled correctly');
+        $this->assertEquals(Op::NotExists, $field->op, 'Operation not filled correctly');
+        $this->assertEquals('', $field->value, 'Value should have been blank');
+        $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
+    }
+
+    #[TestDox('named() succeeds')]
+    public function testNamedSucceeds(): void
+    {
+        $field = Field::named('the_field');
+        $this->assertNotNull($field, 'The field should not have been null');
+        $this->assertEquals('the_field', $field->fieldName, 'Field name not filled correctly');
+        $this->assertEquals(Op::Equal, $field->op, 'Operation not filled correctly');
         $this->assertEquals('', $field->value, 'Value should have been blank');
         $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
     }

tests/unit/Mapper/ArrayMapperTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Mapper;
 
@@ -12,10 +18,11 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('Array Mapper (Unit tests)')]
 class ArrayMapperTest extends TestCase
 {
+    #[TestDox('map() succeeds')]
     public function testMapSucceeds(): void
     {
         $result = ['one' => 2, 'three' => 4, 'eight' => 'five'];
-        $mapped = (new ArrayMapper())->map($result);
+        $mapped = new ArrayMapper()->map($result);
         $this->assertSame($result, $mapped, 'The array mapper should return the parameter given to it');
     }
 }

tests/unit/Mapper/CountMapperTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Mapper;
 
@@ -12,8 +18,9 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('Count Mapper (Unit tests)')]
 class CountMapperTest extends TestCase
 {
+    #[TestDox('map() succeeds')]
     public function testMapSucceeds(): void
     {
-        $this->assertEquals(5, (new CountMapper())->map([5, 8, 10]), 'Count not correct');
+        $this->assertEquals(5, new CountMapper()->map([5, 8, 10]), 'Count not correct');
     }
 }

tests/unit/Mapper/DocumentMapperTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Mapper;
 
@@ -6,6 +12,7 @@ use BitBadger\PDODocument\{DocumentException, Field};
 use BitBadger\PDODocument\Mapper\DocumentMapper;
 use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
+use Test\{PjsonDocument, PjsonId};
 
 // ** Test class hierarchy for serialization **
 
@@ -37,10 +44,10 @@ class DocumentMapperTest extends TestCase
         $this->assertEquals('json', $mapper->fieldName, 'Field name not recorded correctly');
     }
 
-    #[TestDox('Map succeeds with valid JSON')]
+    #[TestDox('map() succeeds with valid JSON')]
     public function testMapSucceedsWithValidJSON(): void
     {
-        $doc = (new DocumentMapper(TestDocument::class))->map(['data' => '{"id":7,"subDoc":{"id":22,"name":"tester"}}']);
+        $doc = new DocumentMapper(TestDocument::class)->map(['data' => '{"id":7,"subDoc":{"id":22,"name":"tester"}}']);
         $this->assertNotNull($doc, 'The document should not have been null');
         $this->assertEquals(7, $doc->id, 'ID not filled correctly');
         $this->assertNotNull($doc->subDoc, 'The sub-document should not have been null');
@@ -48,10 +55,28 @@ class DocumentMapperTest extends TestCase
         $this->assertEquals('tester', $doc->subDoc->name, 'Sub-document name not filled correctly');
     }
 
-    #[TestDox('Map fails with invalid JSON')]
+    #[TestDox('map() succeeds with valid JSON for Pjson class')]
+    public function testMapSucceedsWithValidJSONForPjsonClass(): void
+    {
+        $doc = new DocumentMapper(PjsonDocument::class)->map(['data' => '{"id":"seven","name":"bob","num_value":8}']);
+        $this->assertNotNull($doc, 'The document should not have been null');
+        $this->assertEquals(new PjsonId('seven'), $doc->id, 'ID not filled correctly');
+        $this->assertEquals('bob', $doc->name, 'Name not filled correctly');
+        $this->assertEquals(8, $doc->numValue, 'Numeric value not filled correctly');
+        $this->assertFalse(isset($doc->skipped), 'Non-JSON field has not been set');
+    }
+
+    #[TestDox('map() fails with invalid JSON')]
     public function testMapFailsWithInvalidJSON(): void
     {
         $this->expectException(DocumentException::class);
-        (new DocumentMapper(TestDocument::class))->map(['data' => 'this is not valid']);
+        new DocumentMapper(TestDocument::class)->map(['data' => 'this is not valid']);
+    }
+
+    #[TestDox('map() fails with invalid JSON for Pjson class')]
+    public function testMapFailsWithInvalidJSONForPjsonClass(): void
+    {
+        $this->expectException(DocumentException::class);
+        new DocumentMapper(PjsonDocument::class)->map(['data' => 'not even close']);
     }
 }

tests/unit/Mapper/ExistsMapperTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Mapper;
 
@@ -13,32 +19,33 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('Exists Mapper (Unit tests)')]
 class ExistsMapperTest extends TestCase
 {
-    #[TestDox('Map succeeds for PostgreSQL')]
+    #[TestDox('map() succeeds for PostgreSQL')]
     public function testMapSucceedsForPostgreSQL(): void
     {
         try {
-            Configuration::$mode = Mode::PgSQL;
-            $this->assertFalse((new ExistsMapper())->map([false, 'nope']), 'Result should have been false');
+            Configuration::overrideMode(Mode::PgSQL);
+            $this->assertFalse(new ExistsMapper()->map([false, 'nope']), 'Result should have been false');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('Map succeeds for SQLite')]
+    #[TestDox('map() succeeds for SQLite')]
     public function testMapSucceedsForSQLite(): void
     {
         try {
-            Configuration::$mode = Mode::SQLite;
-            $this->assertTrue((new ExistsMapper())->map([1, 'yep']), 'Result should have been true');
+            Configuration::overrideMode(Mode::SQLite);
+            $this->assertTrue(new ExistsMapper()->map([1, 'yep']), 'Result should have been true');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
+    #[TestDox('map() fails when mode not set')]
     public function testMapFailsWhenModeNotSet(): void
     {
         $this->expectException(DocumentException::class);
-        Configuration::$mode = null;
-        (new ExistsMapper())->map(['0']);
+        Configuration::overrideMode(null);
+        new ExistsMapper()->map(['0']);
     }
 }

tests/unit/Mapper/StringMapperTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Mapper;
 
@@ -12,21 +18,24 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('String Mapper (Unit tests)')]
 class StringMapperTest extends TestCase
 {
-    public function testMapSucceedsWhenFieldIsPresentAndString()
+    #[TestDox('map() succeeds when field is present and string')]
+    public function testMapSucceedsWhenFieldIsPresentAndString(): void
     {
         $result = ['test_field' => 'test_value'];
         $mapper = new StringMapper('test_field');
         $this->assertEquals('test_value', $mapper->map($result), 'String value not returned correctly');
     }
 
-    public function testMapSucceedsWhenFieldIsPresentAndNotString()
+    #[TestDox('map() succeeds when field is present and not string')]
+    public function testMapSucceedsWhenFieldIsPresentAndNotString(): void
     {
         $result = ['a_number' => 6.7];
         $mapper = new StringMapper('a_number');
         $this->assertEquals('6.7', $mapper->map($result), 'Number value not returned correctly');
     }
 
-    public function testMapSucceedsWhenFieldIsNotPresent()
+    #[TestDox('map() succeeds when field is not present')]
+    public function testMapSucceedsWhenFieldIsNotPresent(): void
     {
         $mapper = new StringMapper('something_else');
         $this->assertNull($mapper->map([]), 'Missing value not returned correctly');

tests/unit/ModeTest.php

@@ -0,0 +1,39 @@
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
+
+namespace Test\Unit;
+
+use BitBadger\PDODocument\{DocumentException, Mode};
+use PHPUnit\Framework\Attributes\TestDox;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Unit tests for the Mode enumeration
+ */
+#[TestDox('Mode (Unit tests)')]
+class ModeTest extends TestCase
+{
+    #[TestDox('deriveFromDSN() succeeds for PostgreSQL')]
+    public function testDeriveFromDSNSucceedsForPostgreSQL(): void
+    {
+        $this->assertEquals(Mode::PgSQL, Mode::deriveFromDSN('pgsql:Host=localhost'), 'PostgreSQL mode incorrect');
+    }
+
+    #[TestDox('deriveFromDSN() succeeds for SQLite')]
+    public function testDeriveFromDSNSucceedsForSQLite(): void
+    {
+        $this->assertEquals(Mode::SQLite, Mode::deriveFromDSN('sqlite:data.db'), 'SQLite mode incorrect');
+    }
+
+    #[TestDox('deriveFromDSN() fails for MySQL')]
+    public function testDeriveFromDSNFailsForMySQL(): void
+    {
+        $this->expectException(DocumentException::class);
+        Mode::deriveFromDSN('mysql:Host=localhost');
+    }
+}

tests/unit/OpTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit;
 
@@ -12,57 +18,69 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('Op (Unit tests)')]
 class OpTest extends TestCase
 {
-    #[TestDox('To string succeeds for EQ')]
-    public function testToStringSucceedsForEQ(): void
+    #[TestDox('toSQL() succeeds for Equal')]
+    public function testToSQLSucceedsForEqual(): void
     {
-        $this->assertEquals('=', Op::EQ->toString(), 'EQ operator incorrect');
+        $this->assertEquals('=', Op::Equal->toSQL(), 'Equal SQL operator incorrect');
     }
 
-    #[TestDox('To string succeeds for GT')]
-    public function testToStringSucceedsForGT(): void
+    #[TestDox('toSQL() succeeds for Greater')]
+    public function testToSQLSucceedsForGreater(): void
     {
-        $this->assertEquals('>', Op::GT->toString(), 'GT operator incorrect');
+        $this->assertEquals('>', Op::Greater->toSQL(), 'Greater SQL operator incorrect');
     }
 
-    #[TestDox('To string succeeds for GE')]
-    public function testToStringSucceedsForGE(): void
+    #[TestDox('toSQL() succeeds for GreaterOrEqual')]
+    public function testToSQLSucceedsForGreaterOrEqual(): void
     {
-        $this->assertEquals('>=', Op::GE->toString(), 'GE operator incorrect');
+        $this->assertEquals('>=', Op::GreaterOrEqual->toSQL(), 'GreaterOrEqual SQL operator incorrect');
     }
 
-    #[TestDox('To string succeeds for LT')]
-    public function testToStringSucceedsForLT(): void
+    #[TestDox('toSQL() succeeds for Less')]
+    public function testToSQLSucceedsForLess(): void
     {
-        $this->assertEquals('<', Op::LT->toString(), 'LT operator incorrect');
+        $this->assertEquals('<', Op::Less->toSQL(), 'Less SQL operator incorrect');
     }
 
-    #[TestDox('To string succeeds for LE')]
-    public function testToStringSucceedsForLE(): void
+    #[TestDox('toSQL() succeeds for LessOrEqual')]
+    public function testToSQLSucceedsForLessOrEqual(): void
     {
-        $this->assertEquals('<=', Op::LE->toString(), 'LE operator incorrect');
+        $this->assertEquals('<=', Op::LessOrEqual->toSQL(), 'LessOrEqual SQL operator incorrect');
     }
 
-    #[TestDox('To string succeeds for NE')]
-    public function testToStringSucceedsForNE(): void
+    #[TestDox('toSQL() succeeds for NotEqual')]
+    public function testToSQLSucceedsForNotEqual(): void
     {
-        $this->assertEquals('<>', Op::NE->toString(), 'NE operator incorrect');
+        $this->assertEquals('<>', Op::NotEqual->toSQL(), 'NotEqual SQL operator incorrect');
     }
 
-    #[TestDox('To string succeeds for BT')]
-    public function testToStringSucceedsForBT(): void
+    #[TestDox('toSQL() succeeds for Between')]
+    public function testToSQLSucceedsForBetween(): void
     {
-        $this->assertEquals('BETWEEN', Op::BT->toString(), 'BT operator incorrect');
+        $this->assertEquals('BETWEEN', Op::Between->toSQL(), 'Between SQL operator incorrect');
     }
 
-    #[TestDox('To string succeeds for EX')]
-    public function testToStringSucceedsForEX(): void
+    #[TestDox('toSQL() succeeds for In')]
+    public function testToSQLSucceedsForIn(): void
     {
-        $this->assertEquals('IS NOT NULL', Op::EX->toString(), 'EX operator incorrect');
+        $this->assertEquals('IN', Op::In->toSQL(), 'In SQL operator incorrect');
     }
 
-    #[TestDox('To string succeeds for NEX')]
-    public function testToStringSucceedsForNEX(): void
+    #[TestDox('toSQL() succeeds for InArray')]
+    public function testToSQLSucceedsForInArray(): void
     {
-        $this->assertEquals('IS NULL', Op::NEX->toString(), 'NEX operator incorrect');
+        $this->assertEquals('??|', Op::InArray->toSQL(), 'InArray SQL operator incorrect');
+    }
+
+    #[TestDox('toSQL() succeeds for Exists')]
+    public function testToSQLSucceedsForExists(): void
+    {
+        $this->assertEquals('IS NOT NULL', Op::Exists->toSQL(), 'Exists SQL operator incorrect');
+    }
+
+    #[TestDox('toSQL() succeeds for NotExists')]
+    public function testToSQLSucceedsForNEX(): void
+    {
+        $this->assertEquals('IS NULL', Op::NotExists->toSQL(), 'NotExists SQL operator incorrect');
     }
 }

tests/unit/ParametersTest.php

@@ -1,10 +1,18 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit;
 
 use BitBadger\PDODocument\{Configuration, DocumentException, Field, Mode, Parameters};
 use PHPUnit\Framework\Attributes\TestDox;
 use PHPUnit\Framework\TestCase;
+use stdClass;
+use Test\{PjsonDocument, PjsonId};
 
 /**
  * Unit tests for the Parameters class
@@ -12,69 +20,115 @@ use PHPUnit\Framework\TestCase;
 #[TestDox('Parameters (Unit tests)')]
 class ParametersTest extends TestCase
 {
-    #[TestDox('ID succeeds with string')]
+    #[TestDox('id() succeeds with string')]
     public function testIdSucceedsWithString(): void
     {
         $this->assertEquals([':id' => 'key'], Parameters::id('key'), 'ID parameter not constructed correctly');
     }
 
-    #[TestDox('ID succeeds with non string')]
+    #[TestDox('id() succeeds with non string')]
     public function testIdSucceedsWithNonString(): void
     {
         $this->assertEquals([':id' => '7'], Parameters::id(7), 'ID parameter not constructed correctly');
     }
 
-    public function testJsonSucceeds(): void
+    #[TestDox('json() succeeds for array')]
+    public function testJsonSucceedsForArray(): void
     {
         $this->assertEquals([':it' => '{"id":18,"url":"https://www.unittest.com"}'],
             Parameters::json(':it', ['id' => 18, 'url' => 'https://www.unittest.com']),
             'JSON parameter not constructed correctly');
     }
 
+    #[TestDox('json() succeeds for array with empty array parameter')]
+    public function testJsonSucceedsForArrayWithEmptyArrayParameter(): void
+    {
+        $this->assertEquals([':it' => '{"id":18,"urls":[]}'], Parameters::json(':it', ['id' => 18, 'urls' => []]),
+            'JSON parameter not constructed correctly');
+    }
+
+    #[TestDox('json() succeeds for 1D array with empty array parameter')]
+    public function testJsonSucceedsFor1DArrayWithEmptyArrayParameter(): void
+    {
+        $this->assertEquals([':it' => '{"urls":[]}'], Parameters::json(':it', ['urls' => []]),
+            'JSON parameter not constructed correctly');
+    }
+
+    #[TestDox('json() succeeds for stdClass')]
+    public function testJsonSucceedsForStdClass(): void
+    {
+        $obj      = new stdClass();
+        $obj->id  = 19;
+        $obj->url = 'https://testhere.info';
+        $this->assertEquals([':it' => '{"id":19,"url":"https://testhere.info"}'], Parameters::json(':it', $obj),
+            'JSON parameter not constructed correctly');
+    }
+
+    #[TestDox('json() succeeds for Pjson class')]
+    public function testJsonSucceedsForPjsonClass(): void
+    {
+        $this->assertEquals([':it' => '{"id":"999","name":"a test","num_value":98}'],
+            Parameters::json(':it', new PjsonDocument(new PjsonId('999'), 'a test', 98, 'nothing')),
+            'JSON parameter not constructed correctly');
+    }
+
+    #[TestDox('json() succeeds for array of Pjson class')]
+    public function testJsonSucceedsForArrayOfPjsonClass(): void
+    {
+        $this->assertEquals([':it' => '{"pjson":[{"id":"997","name":"another test","num_value":94}]}'],
+            Parameters::json(':it',
+                ['pjson' => [new PjsonDocument(new PjsonId('997'), 'another test', 94, 'nothing')]]),
+            'JSON parameter not constructed correctly');
+    }
+
+    #[TestDox('nameFields() succeeds')]
     public function testNameFieldsSucceeds(): void
     {
-        $named = Parameters::nameFields([Field::EQ('it', 17), Field::EQ('also', 22, ':also'), Field::EQ('other', 24)]);
+        $named = [Field::equal('it', 17), Field::equal('also', 22, ':also'), Field::equal('other', 24)];
+        Parameters::nameFields($named);
         $this->assertCount(3, $named, 'There should be 3 parameters in the array');
         $this->assertEquals(':field0', $named[0]->paramName, 'Parameter 1 not named correctly');
         $this->assertEquals(':also', $named[1]->paramName, 'Parameter 2 not named correctly');
         $this->assertEquals(':field2', $named[2]->paramName, 'Parameter 3 not named correctly');
     }
 
+    #[TestDox('addFields() succeeds')]
     public function testAddFieldsSucceeds(): void
     {
         $this->assertEquals([':a' => 1, ':b' => 'two', ':z' => 18],
-            Parameters::addFields([Field::EQ('b', 'two', ':b'), Field::EQ('z', 18, ':z')], [':a' => 1]),
+            Parameters::addFields([Field::equal('b', 'two', ':b'), Field::equal('z', 18, ':z')], [':a' => 1]),
             'Field parameters not added correctly');
     }
 
-    #[TestDox('Field names succeeds for PostgreSQL')]
+    #[TestDox('fieldNames() succeeds for PostgreSQL')]
     public function testFieldNamesSucceedsForPostgreSQL(): void
     {
         try {
-            Configuration::$mode = Mode::PgSQL;
+            Configuration::overrideMode(Mode::PgSQL);
             $this->assertEquals([':names' => "{one,two,seven}"],
                 Parameters::fieldNames(':names', ['one', 'two', 'seven']), 'Field name parameters not correct');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
-    #[TestDox('Field names succeeds for SQLite')]
+    #[TestDox('fieldNames() succeeds for SQLite')]
     public function testFieldNamesSucceedsForSQLite(): void
     {
         try {
-            Configuration::$mode = Mode::SQLite;
+            Configuration::overrideMode(Mode::SQLite);
             $this->assertEquals([':it0' => '$.test', ':it1' => '$.unit', ':it2' => '$.wow'],
                 Parameters::fieldNames(':it', ['test', 'unit', 'wow']), 'Field name parameters not correct');
         } finally {
-            Configuration::$mode = null;
+            Configuration::overrideMode(null);
         }
     }
 
+    #[TestDox('fieldNames() fails when mode not set')]
     public function testFieldNamesFailsWhenModeNotSet(): void
     {
         $this->expectException(DocumentException::class);
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
         Parameters::fieldNames('', []);
     }
 }

tests/unit/Query/CountTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Query;
 
@@ -15,48 +21,50 @@ class CountTest extends TestCase
 {
     public function tearDown(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
         parent::tearDown();
     }
 
+    #[TestDox('all() succeeds')]
     public function testAllSucceeds(): void
     {
         $this->assertEquals('SELECT COUNT(*) FROM a_table', Count::all('a_table'),
             'SELECT statement not generated correctly');
     }
 
+    #[TestDox('byFields() succeeds')]
     public function testByFieldsSucceeds(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals("SELECT COUNT(*) FROM somewhere WHERE data->>'errors' > :errors",
-            Count::byFields('somewhere', [Field::GT('errors', 10, ':errors')]),
+            Count::byFields('somewhere', [Field::greater('errors', 10, ':errors')]),
             'SELECT statement not generated correctly');
     }
 
-    #[TestDox('By contains succeeds for PostgreSQL')]
+    #[TestDox('byContains() succeeds for PostgreSQL')]
     public function testByContainsSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('SELECT COUNT(*) FROM the_table WHERE data @> :criteria', Count::byContains('the_table'),
             'SELECT statement not generated correctly');
     }
 
-    #[TestDox('By contains fails for non PostgreSQL')]
+    #[TestDox('byContains() fails for non PostgreSQL')]
     public function testByContainsFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);
         Count::byContains('');
     }
 
-    #[TestDox('By JSON Path succeeds for PostgreSQL')]
+    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
     public function testByJsonPathSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('SELECT COUNT(*) FROM a_table WHERE jsonb_path_exists(data, :path::jsonpath)',
             Count::byJsonPath('a_table'), 'SELECT statement not generated correctly');
     }
 
-    #[TestDox('By JSON Path fails for non PostgreSQL')]
+    #[TestDox('byJsonPath() fails for non PostgreSQL')]
     public function testByJsonPathFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);

tests/unit/Query/DefinitionTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Query;
 
@@ -15,38 +21,41 @@ class DefinitionTest extends TestCase
 {
     protected function tearDown(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
         parent::tearDown();
     }
 
-    #[TestDox('Ensure table succeeds for PosgtreSQL')]
+    #[TestDox('ensureTable() succeeds for PostgreSQL')]
     public function testEnsureTableSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('CREATE TABLE IF NOT EXISTS documents (data JSONB NOT NULL)',
             Definition::ensureTable('documents'), 'CREATE TABLE statement not generated correctly');
     }
 
-    #[TestDox('Ensure table succeeds for SQLite')]
+    #[TestDox('ensureTable() succeeds for SQLite')]
     public function testEnsureTableSucceedsForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals('CREATE TABLE IF NOT EXISTS dox (data TEXT NOT NULL)', Definition::ensureTable('dox'),
             'CREATE TABLE statement not generated correctly');
     }
 
+    #[TestDox('ensureTable() fails when mode not set')]
     public function testEnsureTableFailsWhenModeNotSet(): void
     {
         $this->expectException(DocumentException::class);
         Definition::ensureTable('boom');
     }
 
+    #[TestDox('ensureIndexOn() succeeds without schema single ascending field')]
     public function testEnsureIndexOnSucceedsWithoutSchemaSingleAscendingField(): void
     {
         $this->assertEquals("CREATE INDEX IF NOT EXISTS idx_test_fields ON test ((data->>'details'))",
             Definition::ensureIndexOn('test', 'fields', ['details']), 'CREATE INDEX statement not generated correctly');
     }
 
+    #[TestDox('ensureIndexOn() succeeds with schema multiple fields')]
     public function testEnsureIndexOnSucceedsWithSchemaMultipleFields(): void
     {
         $this->assertEquals(
@@ -55,27 +64,30 @@ class DefinitionTest extends TestCase
             'CREATE INDEX statement not generated correctly');
     }
 
+    #[TestDox('ensureKey() succeeds')]
     public function testEnsureKeySucceeds(): void
     {
         $this->assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS idx_tbl_key ON tbl ((data->>'id'))",
             Definition::ensureKey('tbl'), 'CREATE INDEX statement for document key not generated correctly');
     }
 
+    #[TestDox('ensureDocumentIndexOn() succeeds for schema and Full')]
     public function testEnsureDocumentIndexOnSucceedsForSchemaAndFull(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals("CREATE INDEX IF NOT EXISTS idx_tbl_document ON my.tbl USING GIN (data)",
             Definition::ensureDocumentIndexOn('my.tbl', DocumentIndex::Full));
     }
 
+    #[TestDox('ensureDocumentIndexOn() succeeds for no schema and Optimized')]
     public function testEnsureDocumentIndexOnSucceedsForNoSchemaAndOptimized(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals("CREATE INDEX IF NOT EXISTS idx_it_document ON it USING GIN (data jsonb_path_ops)",
             Definition::ensureDocumentIndexOn('it', DocumentIndex::Optimized));
     }
 
-    #[TestDox('Ensure document index on fails for non PostgreSQL')]
+    #[TestDox('ensureDocumentIndexOn() fails for non PostgreSQL')]
     public function testEnsureDocumentIndexOnFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);

tests/unit/Query/DeleteTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Query;
 
@@ -15,49 +21,51 @@ class DeleteTest extends TestCase
 {
     protected function tearDown(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
     }
 
-    #[TestDox('By ID succeeds')]
+    #[TestDox('byId() succeeds')]
     public function testByIdSucceeds(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals("DELETE FROM over_there WHERE data->>'id' = :id", Delete::byId('over_there'),
             'DELETE statement not constructed correctly');
     }
 
+    #[TestDox('byFields() succeeds')]
     public function testByFieldsSucceeds(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals("DELETE FROM my_table WHERE data->>'value' < :max AND data->>'value' >= :min",
-            Delete::byFields('my_table', [Field::LT('value', 99, ':max'), Field::GE('value', 18, ':min')]),
+            Delete::byFields('my_table',
+                [Field::less('value', 99, ':max'), Field::greaterOrEqual('value', 18, ':min')]),
             'DELETE statement not constructed correctly');
     }
 
-    #[TestDox('By contains succeeds for PostgreSQL')]
+    #[TestDox('byContains() succeeds for PostgreSQL')]
     public function testByContainsSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('DELETE FROM somewhere WHERE data @> :criteria', Delete::byContains('somewhere'),
             'DELETE statement not constructed correctly');
     }
 
-    #[TestDox('By contains fails for non PostgreSQL')]
+    #[TestDox('byContains() fails for non PostgreSQL')]
     public function testByContainsFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);
         Delete::byContains('');
     }
 
-    #[TestDox('By JSON Path succeeds for PostgreSQL')]
+    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
     public function testByJsonPathSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('DELETE FROM here WHERE jsonb_path_exists(data, :path::jsonpath)',
             Delete::byJsonPath('here'), 'DELETE statement not constructed correctly');
     }
 
-    #[TestDox('By JSON Path fails for non PostgreSQL')]
+    #[TestDox('byJsonPath() fails for non PostgreSQL')]
     public function testByJsonPathFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);

tests/unit/Query/ExistsTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Query;
 
@@ -15,56 +21,58 @@ class ExistsTest extends TestCase
 {
     protected function tearDown(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
     }
 
+    #[TestDox('query() succeeds')]
     public function testQuerySucceeds(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals('SELECT EXISTS (SELECT 1 FROM abc WHERE def)', Exists::query('abc', 'def'),
             'Existence query not generated correctly');
     }
 
-    #[TestDox('By ID succeeds')]
+    #[TestDox('byId() succeeds')]
     public function testByIdSucceeds(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals("SELECT EXISTS (SELECT 1 FROM dox WHERE data->>'id' = :id)", Exists::byId('dox'),
             'Existence query not generated correctly');
     }
 
+    #[TestDox('byFields() succeeds')]
     public function testByFieldsSucceeds(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals("SELECT EXISTS (SELECT 1 FROM box WHERE data->>'status' <> :status)",
-            Exists::byFields('box', [Field::NE('status', 'occupied', ':status')]),
+            Exists::byFields('box', [Field::notEqual('status', 'occupied', ':status')]),
             'Existence query not generated correctly');
     }
 
-    #[TestDox('By contains succeeds for PostgreSQL')]
+    #[TestDox('byContains() succeeds for PostgreSQL')]
     public function testByContainsSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('SELECT EXISTS (SELECT 1 FROM pocket WHERE data @> :criteria)',
             Exists::byContains('pocket'), 'Existence query not generated correctly');
     }
 
-    #[TestDox('By contains fails for non PostgreSQL')]
+    #[TestDox('byContains() fails for non PostgreSQL')]
     public function testByContainsFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);
         Exists::byContains('');
     }
 
-    #[TestDox('By JSON Path succeeds for PostgreSQL')]
+    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
     public function testByJsonPathSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('SELECT EXISTS (SELECT 1 FROM lint WHERE jsonb_path_exists(data, :path::jsonpath))',
             Exists::byJsonPath('lint'), 'Existence query not generated correctly');
     }
 
-    #[TestDox('By JSON Path fails for non PostgreSQL')]
+    #[TestDox('byJsonPath() fails for non PostgreSQL')]
     public function testByJsonPathFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);

tests/unit/Query/FindTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Query;
 
@@ -15,50 +21,51 @@ class FindTest extends TestCase
 {
     protected function tearDown(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
     }
 
-    #[TestDox('By ID succeeds')]
+    #[TestDox('byId() succeeds')]
     public function testByIdSucceeds(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals("SELECT data FROM here WHERE data->>'id' = :id", Find::byId('here'),
             'SELECT query not generated correctly');
     }
 
+    #[TestDox('byFields() succeeds')]
     public function testByFieldsSucceeds(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals("SELECT data FROM there WHERE data->>'active' = :act OR data->>'locked' = :lock",
-            Find::byFields('there', [Field::EQ('active', true, ':act'), Field::EQ('locked', true, ':lock')],
+            Find::byFields('there', [Field::equal('active', true, ':act'), Field::equal('locked', true, ':lock')],
                 FieldMatch::Any),
             'SELECT query not generated correctly');
     }
 
-    #[TestDox('By contains succeeds for PostgreSQL')]
+    #[TestDox('byContains() succeeds for PostgreSQL')]
     public function testByContainsSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('SELECT data FROM disc WHERE data @> :criteria', Find::byContains('disc'),
             'SELECT query not generated correctly');
     }
 
-    #[TestDox('By contains fails for non PostgreSQL')]
+    #[TestDox('byContains() fails for non PostgreSQL')]
     public function testByContainsFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);
         Find::byContains('');
     }
 
-    #[TestDox('By JSON Path succeeds for PostgreSQL')]
+    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
     public function testByJsonPathSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('SELECT data FROM light WHERE jsonb_path_exists(data, :path::jsonpath)',
             Find::byJsonPath('light'), 'SELECT query not generated correctly');
     }
 
-    #[TestDox('By JSON Path fails for non PostgreSQL')]
+    #[TestDox('byJsonPath() fails for non PostgreSQL')]
     public function testByJsonPathFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);

tests/unit/Query/PatchTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Query;
 
@@ -15,79 +21,81 @@ class PatchTest extends TestCase
 {
     protected function tearDown(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
         parent::tearDown();
     }
-    #[TestDox('By ID succeeds for PostgreSQL')]
+    #[TestDox('byId() succeeds for PostgreSQL')]
     public function testByIdSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals("UPDATE doc_table SET data = data || :data WHERE data->>'id' = :id",
             Patch::byId('doc_table'), 'Patch UPDATE statement is not correct');
     }
 
-    #[TestDox('By ID succeeds for SQLite')]
+    #[TestDox('byId() succeeds for SQLite')]
     public function testByIdSucceedsForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals("UPDATE my_table SET data = json_patch(data, json(:data)) WHERE data->>'id' = :id",
             Patch::byId('my_table'), 'Patch UPDATE statement is not correct');
     }
 
-    #[TestDox('By ID fails when mode not set')]
+    #[TestDox('byId() fails when mode not set')]
     public function testByIdFailsWhenModeNotSet(): void
     {
         $this->expectException(DocumentException::class);
         Patch::byId('oof');
     }
 
-    #[TestDox('By fields succeeds for PostgreSQL')]
+    #[TestDox('byFields() succeeds for PostgreSQL')]
     public function testByFieldsSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals("UPDATE that SET data = data || :data WHERE (data->>'something')::numeric < :some",
-            Patch::byFields('that', [Field::LT('something', 17, ':some')]), 'Patch UPDATE statement is not correct');
+            Patch::byFields('that', [Field::less('something', 17, ':some')]), 'Patch UPDATE statement is not correct');
     }
 
-    #[TestDox('By fields succeeds for SQLite')]
+    #[TestDox('byFields() succeeds for SQLite')]
     public function testByFieldsSucceedsForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals(
             "UPDATE a_table SET data = json_patch(data, json(:data)) WHERE data->>'something' > :it",
-            Patch::byFields('a_table', [Field::GT('something', 17, ':it')]), 'Patch UPDATE statement is not correct');
+            Patch::byFields('a_table', [Field::greater('something', 17, ':it')]),
+                'Patch UPDATE statement is not correct');
     }
 
+    #[TestDox('byFields() fails when mode not set')]
     public function testByFieldsFailsWhenModeNotSet(): void
     {
         $this->expectException(DocumentException::class);
         Patch::byFields('oops', []);
     }
 
-    #[TestDox('By contains succeeds for PostgreSQL')]
+    #[TestDox('byContains() succeeds for PostgreSQL')]
     public function testByContainsSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('UPDATE this SET data = data || :data WHERE data @> :criteria', Patch::byContains('this'),
             'Patch UPDATE statement is not correct');
     }
 
-    #[TestDox('By contains fails for non PostgreSQL')]
+    #[TestDox('byContains() fails for non PostgreSQL')]
     public function testByContainsFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);
         Patch::byContains('');
     }
 
-    #[TestDox('By JSON Path succeeds for PostgreSQL')]
+    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
     public function testByJsonPathSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('UPDATE that SET data = data || :data WHERE jsonb_path_exists(data, :path::jsonpath)',
             Patch::byJsonPath('that'), 'Patch UPDATE statement is not correct');
     }
 
-    #[TestDox('By JSON Path fails for non PostgreSQL')]
+    #[TestDox('byJsonPath() fails for non PostgreSQL')]
     public function testByJsonPathFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);

tests/unit/Query/RemoveFieldsTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit\Query;
 
@@ -15,110 +21,112 @@ class RemoveFieldsTest extends TestCase
 {
     protected function tearDown(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
     }
 
-    #[TestDox('Update succeeds for PostgreSQL')]
+    #[TestDox('update() succeeds for PostgreSQL')]
     public function testUpdateSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('UPDATE taco SET data = data - :names::text[] WHERE it = true',
             RemoveFields::update('taco', [':names' => "{one,two}"], 'it = true'), 'UPDATE statement not correct');
     }
 
-    #[TestDox('Update succeeds for SQLite')]
+    #[TestDox('update() succeeds for SQLite')]
     public function testUpdateSucceedsForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals('UPDATE burrito SET data = json_remove(data, :name0, :name1, :name2) WHERE a = b',
             RemoveFields::update('burrito', Parameters::fieldNames(':name', ['one', 'two', 'ten']), 'a = b'),
             'UPDATE statement not correct');
     }
 
+    #[TestDox('update() fails when mode not set')]
     public function testUpdateFailsWhenModeNotSet(): void
     {
         $this->expectException(DocumentException::class);
         RemoveFields::update('wow', [], '');
     }
 
-    #[TestDox('By ID succeeds for PostgreSQL')]
-    public function testByIdSucceedsForPostgreSQL()
+    #[TestDox('byId() succeeds for PostgreSQL')]
+    public function testByIdSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals("UPDATE churro SET data = data - :bite::text[] WHERE data->>'id' = :id",
             RemoveFields::byId('churro', Parameters::fieldNames(':bite', ['byte'])), 'UPDATE statement not correct');
     }
 
-    #[TestDox('By ID succeeds for SQLite')]
-    public function testByIdSucceedsForSQLite()
+    #[TestDox('byId() succeeds for SQLite')]
+    public function testByIdSucceedsForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals("UPDATE quesadilla SET data = json_remove(data, :bite0) WHERE data->>'id' = :id",
             RemoveFields::byId('quesadilla', Parameters::fieldNames(':bite', ['byte'])),
             'UPDATE statement not correct');
     }
 
-    #[TestDox('By ID fails when mode not set')]
+    #[TestDox('byId() fails when mode not set')]
     public function testByIdFailsWhenModeNotSet(): void
     {
         $this->expectException(DocumentException::class);
         RemoveFields::byId('oof', []);
     }
 
-    #[TestDox('By fields succeeds for PostgreSQL')]
-    public function testByFieldsSucceedsForPostgreSQL()
+    #[TestDox('byFields() succeeds for PostgreSQL')]
+    public function testByFieldsSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals("UPDATE enchilada SET data = data - :sauce::text[] WHERE data->>'cheese' = :queso",
-            RemoveFields::byFields('enchilada', [Field::EQ('cheese', 'jack', ':queso')],
+            RemoveFields::byFields('enchilada', [Field::equal('cheese', 'jack', ':queso')],
                 Parameters::fieldNames(':sauce', ['white'])),
             'UPDATE statement not correct');
     }
 
-    #[TestDox('By fields succeeds for SQLite')]
-    public function testByFieldsSucceedsForSQLite()
+    #[TestDox('byFields() succeeds for SQLite')]
+    public function testByFieldsSucceedsForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
         $this->assertEquals(
             "UPDATE chimichanga SET data = json_remove(data, :filling0) WHERE data->>'side' = :rice",
-            RemoveFields::byFields('chimichanga', [Field::EQ('side', 'beans', ':rice')],
+            RemoveFields::byFields('chimichanga', [Field::equal('side', 'beans', ':rice')],
                 Parameters::fieldNames(':filling', ['beef'])),
             'UPDATE statement not correct');
     }
 
+    #[TestDox('byFields() fails when mode not set')]
     public function testByFieldsFailsWhenModeNotSet(): void
     {
         $this->expectException(DocumentException::class);
         RemoveFields::byFields('boing', [], []);
     }
 
-    #[TestDox('By contains succeeds for PostgreSQL')]
+    #[TestDox('byContains() succeeds for PostgreSQL')]
     public function testByContainsSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals('UPDATE food SET data = data - :drink::text[] WHERE data @> :criteria',
             RemoveFields::byContains('food', Parameters::fieldNames(':drink', ['a', 'b'])),
             'UPDATE statement not correct');
     }
 
-    #[TestDox('By contains fails for non PostgreSQL')]
+    #[TestDox('byContains() fails for non PostgreSQL')]
     public function testByContainsFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);
         RemoveFields::byContains('', []);
     }
 
-    #[TestDox('By JSON Path succeeds for PostgreSQL')]
+    #[TestDox('byJsonPath() succeeds for PostgreSQL')]
     public function testByJsonPathSucceedsForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         $this->assertEquals(
             'UPDATE dessert SET data = data - :cake::text[] WHERE jsonb_path_exists(data, :path::jsonpath)',
             RemoveFields::byJsonPath('dessert', Parameters::fieldNames(':cake', ['b', 'c'])),
             'UPDATE statement not correct');
     }
 
-    #[TestDox('By JSON Path fails for non PostgreSQL')]
+    #[TestDox('byJsonPath() fails for non PostgreSQL')]
     public function testByJsonPathFailsForNonPostgreSQL(): void
     {
         $this->expectException(DocumentException::class);

tests/unit/QueryTest.php

@@ -1,4 +1,10 @@
-<?php declare(strict_types=1);
+<?php
+/**
+ * @author Daniel J. Summers <daniel@bitbadger.solutions>
+ * @license MIT
+ */
+
+declare(strict_types=1);
 
 namespace Test\Unit;
 
@@ -14,199 +20,164 @@ class QueryTest extends TestCase
 {
     protected function setUp(): void
     {
-        Configuration::$mode = Mode::SQLite;
+        Configuration::overrideMode(Mode::SQLite);
     }
 
     protected function tearDown(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
     }
 
+    #[TestDox('selectFromTable() succeeds')]
     public function testSelectFromTableSucceeds(): void
     {
         $this->assertEquals('SELECT data FROM testing', Query::selectFromTable('testing'),
             'Query not constructed correctly');
     }
 
+    #[TestDox('whereByFields() succeeds for single field')]
     public function testWhereByFieldsSucceedsForSingleField(): void
     {
         $this->assertEquals("data->>'test_field' <= :it",
-            Query::whereByFields([Field::LE('test_field', '', ':it')]), 'WHERE fragment not constructed correctly');
-    }
-
-    public function testWhereByFieldsSucceedsForMultipleFieldsAll(): void
-    {
-        $this->assertEquals("data->>'test_field' <= :it AND data->>'other_field' = :other",
-            Query::whereByFields([Field::LE('test_field', '', ':it'), Field::EQ('other_field', '', ':other')]),
+            Query::whereByFields([Field::lessOrEqual('test_field', '', ':it')]),
             'WHERE fragment not constructed correctly');
     }
 
+    #[TestDox('whereByFields() succeeds for multiple fields All')]
+    public function testWhereByFieldsSucceedsForMultipleFieldsAll(): void
+    {
+        $this->assertEquals("data->>'test_field' <= :it AND data->>'other_field' = :other",
+            Query::whereByFields(
+                [Field::lessOrEqual('test_field', '', ':it'), Field::equal('other_field', '', ':other')]),
+            'WHERE fragment not constructed correctly');
+    }
+
+    #[TestDox('whereByFields() succeeds for multiple fields Any')]
     public function testWhereByFieldsSucceedsForMultipleFieldsAny(): void
     {
         $this->assertEquals("data->>'test_field' <= :it OR data->>'other_field' = :other",
-            Query::whereByFields([Field::LE('test_field', '', ':it'), Field::EQ('other_field', '', ':other')],
+            Query::whereByFields(
+                [Field::lessOrEqual('test_field', '', ':it'), Field::equal('other_field', '', ':other')],
                 FieldMatch::Any),
             'WHERE fragment not constructed correctly');
     }
 
-    #[TestDox('Where by ID succeeds with default parameter')]
+    #[TestDox('whereById() succeeds with default parameter')]
     public function testWhereByIdSucceedsWithDefaultParameter(): void
     {
         $this->assertEquals("data->>'id' = :id", Query::whereById(), 'WHERE fragment not constructed correctly');
     }
 
-    #[TestDox('Where by ID succeeds with specific parameter')]
+    #[TestDox('whereById() succeeds with specific parameter')]
     public function testWhereByIdSucceedsWithSpecificParameter(): void
     {
         $this->assertEquals("data->>'id' = :di", Query::whereById(':di'), 'WHERE fragment not constructed correctly');
     }
 
+    #[TestDox('whereDataContains() succeeds with default parameter')]
     public function testWhereDataContainsSucceedsWithDefaultParameter(): void
     {
-        Configuration::$mode = Mode::PgSQL;
-        try {
-            $this->assertEquals('data @> :criteria', Query::whereDataContains(),
-                'WHERE fragment not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals('data @> :criteria', Query::whereDataContains(),
+            'WHERE fragment not constructed correctly');
     }
 
+    #[TestDox('whereDataContains() succeeds with specific parameter')]
     public function testWhereDataContainsSucceedsWithSpecifiedParameter(): void
     {
-        Configuration::$mode = Mode::PgSQL;
-        try {
-            $this->assertEquals('data @> :it', Query::whereDataContains(':it'),
-                'WHERE fragment not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals('data @> :it', Query::whereDataContains(':it'), 'WHERE fragment not constructed correctly');
     }
 
-    #[TestDox('Where data contains fails if not PostgreSQL')]
+    #[TestDox('whereDataContains() fails if not PostgreSQL')]
     public function testWhereDataContainsFailsIfNotPostgreSQL(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
         $this->expectException(DocumentException::class);
         Query::whereDataContains();
     }
 
-    #[TestDox('Where JSON Path matches succeeds with default parameter')]
+    #[TestDox('whereJsonPathMatches() succeeds with default parameter')]
     public function testWhereJsonPathMatchesSucceedsWithDefaultParameter(): void
     {
-        Configuration::$mode = Mode::PgSQL;
-        try {
-            $this->assertEquals('jsonb_path_exists(data, :path::jsonpath)', Query::whereJsonPathMatches(),
-                'WHERE fragment not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals('jsonb_path_exists(data, :path::jsonpath)', Query::whereJsonPathMatches(),
+            'WHERE fragment not constructed correctly');
     }
 
-    #[TestDox('Where JSON Path matches succeeds with specified parameter')]
+    #[TestDox('whereJsonPathMatches() succeeds with specified parameter')]
     public function testWhereJsonPathMatchesSucceedsWithSpecifiedParameter(): void
     {
-        Configuration::$mode = Mode::PgSQL;
-        try {
-            $this->assertEquals('jsonb_path_exists(data, :road::jsonpath)', Query::whereJsonPathMatches(':road'),
-                'WHERE fragment not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals('jsonb_path_exists(data, :road::jsonpath)', Query::whereJsonPathMatches(':road'),
+            'WHERE fragment not constructed correctly');
     }
 
-    #[TestDox('Where JSON Path matches fails if not PostgreSQL')]
+    #[TestDox('whereJsonPathMatches() fails if not PostgreSQL')]
     public function testWhereJsonPathMatchesFailsIfNotPostgreSQL(): void
     {
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
         $this->expectException(DocumentException::class);
         Query::whereJsonPathMatches();
     }
 
-    #[TestDox('Insert succeeds with no auto-ID for PostgreSQL')]
+    #[TestDox('insert() succeeds with no auto-ID for PostgreSQL')]
     public function testInsertSucceedsWithNoAutoIdForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
-        try {
-            $this->assertEquals('INSERT INTO test_tbl VALUES (:data)', Query::insert('test_tbl'),
-                'INSERT statement not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals('INSERT INTO test_tbl VALUES (:data)', Query::insert('test_tbl'),
+            'INSERT statement not constructed correctly');
     }
 
-    #[TestDox('Insert succeeds with no auto-ID for SQLite')]
+    #[TestDox('insert() succeeds with no auto-ID for SQLite')]
     public function testInsertSucceedsWithNoAutoIdForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
-        try {
-            $this->assertEquals('INSERT INTO test_tbl VALUES (:data)', Query::insert('test_tbl'),
-                'INSERT statement not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        $this->assertEquals('INSERT INTO test_tbl VALUES (:data)', Query::insert('test_tbl'),
+            'INSERT statement not constructed correctly');
     }
 
-    #[TestDox('Insert succeeds with auto numeric ID for PostgreSQL')]
+    #[TestDox('insert() succeeds with auto numeric ID for PostgreSQL')]
     public function testInsertSucceedsWithAutoNumericIdForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
-        try {
-            $this->assertEquals(
-                "INSERT INTO test_tbl VALUES (:data::jsonb || ('{\"id\":' "
-                    . "|| (SELECT COALESCE(MAX((data->>'id')::numeric), 0) + 1 FROM test_tbl) || '}')::jsonb)",
-                Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals(
+            "INSERT INTO test_tbl VALUES (:data::jsonb || ('{\"id\":' "
+                . "|| (SELECT COALESCE(MAX((data->>'id')::numeric), 0) + 1 FROM test_tbl) || '}')::jsonb)",
+            Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly');
     }
 
-    #[TestDox('Insert succeeds with auto numeric ID for SQLite')]
+    #[TestDox('insert() succeeds with auto numeric ID for SQLite')]
     public function testInsertSucceedsWithAutoNumericIdForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
-        try {
-            $this->assertEquals(
-                "INSERT INTO test_tbl VALUES (json_set(:data, '$.id', "
-                    . "(SELECT coalesce(max(data->>'id'), 0) + 1 FROM test_tbl)))",
-                Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        $this->assertEquals(
+            "INSERT INTO test_tbl VALUES (json_set(:data, '$.id', "
+                . "(SELECT coalesce(max(data->>'id'), 0) + 1 FROM test_tbl)))",
+            Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly');
     }
 
-    #[TestDox('Insert succeeds with auto UUID for PostgreSQL')]
+    #[TestDox('insert() succeeds with auto UUID for PostgreSQL')]
     public function testInsertSucceedsWithAutoUuidForPostgreSQL(): void
     {
-        Configuration::$mode = Mode::PgSQL;
-        try {
-            $query = Query::insert('test_tbl', AutoId::UUID);
-            $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (:data::jsonb || '{\"id\":\"", $query,
-                'INSERT statement not constructed correctly');
-            $this->assertStringEndsWith("\"}')", $query, 'INSERT statement not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        Configuration::overrideMode(Mode::PgSQL);
+        $query = Query::insert('test_tbl', AutoId::UUID);
+        $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (:data::jsonb || '{\"id\":\"", $query,
+            'INSERT statement not constructed correctly');
+        $this->assertStringEndsWith("\"}')", $query, 'INSERT statement not constructed correctly');
     }
 
-    #[TestDox('Insert succeeds with auto UUID for SQLite')]
+    #[TestDox('insert() succeeds with auto UUID for SQLite')]
     public function testInsertSucceedsWithAutoUuidForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
-        try {
-            $query = Query::insert('test_tbl', AutoId::UUID);
-            $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", $query,
-                'INSERT statement not constructed correctly');
-            $this->assertStringEndsWith("'))", $query, 'INSERT statement not constructed correctly');
-        } finally {
-            Configuration::$mode = null;
-        }
+        $query = Query::insert('test_tbl', AutoId::UUID);
+        $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", $query,
+            'INSERT statement not constructed correctly');
+        $this->assertStringEndsWith("'))", $query, 'INSERT statement not constructed correctly');
     }
 
-    #[TestDox('Insert succeeds with auto random string for PostgreSQL')]
+    #[TestDox('insert() succeeds with auto random string for PostgreSQL')]
     public function testInsertSucceedsWithAutoRandomStringForPostgreSQL(): void
     {
-        Configuration::$mode           = Mode::PgSQL;
+        Configuration::overrideMode(Mode::PgSQL);
         Configuration::$idStringLength = 8;
         try {
             $query = Query::insert('test_tbl', AutoId::RandomString);
@@ -216,34 +187,30 @@ class QueryTest extends TestCase
             $id = str_replace(["INSERT INTO test_tbl VALUES (:data::jsonb || '{\"id\":\"", "\"}')"], '', $query);
             $this->assertEquals(8, strlen($id), "Generated ID [$id] should have been 8 characters long");
         } finally {
-            Configuration::$mode           = null;
             Configuration::$idStringLength = 16;
         }
     }
 
-    #[TestDox('Insert succeeds with auto random string for SQLite')]
+    #[TestDox('insert() succeeds with auto random string for SQLite')]
     public function testInsertSucceedsWithAutoRandomStringForSQLite(): void
     {
-        Configuration::$mode = Mode::SQLite;
-        try {
-            $query = Query::insert('test_tbl', AutoId::RandomString);
-            $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", $query,
-                'INSERT statement not constructed correctly');
-            $this->assertStringEndsWith("'))", $query, 'INSERT statement not constructed correctly');
-            $id = str_replace(["INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", "'))"], '', $query);
-            $this->assertEquals(16, strlen($id), "Generated ID [$id] should have been 16 characters long");
-        } finally {
-            Configuration::$mode = null;
-        }
+        $query = Query::insert('test_tbl', AutoId::RandomString);
+        $this->assertStringStartsWith("INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", $query,
+            'INSERT statement not constructed correctly');
+        $this->assertStringEndsWith("'))", $query, 'INSERT statement not constructed correctly');
+        $id = str_replace(["INSERT INTO test_tbl VALUES (json_set(:data, '$.id', '", "'))"], '', $query);
+        $this->assertEquals(16, strlen($id), "Generated ID [$id] should have been 16 characters long");
     }
 
+    #[TestDox('insert() fails when mode not set')]
     public function testInsertFailsWhenModeNotSet(): void
     {
         $this->expectException(DocumentException::class);
-        Configuration::$mode = null;
+        Configuration::overrideMode(null);
         Query::insert('kaboom');
     }
 
+    #[TestDox('save() succeeds')]
     public function testSaveSucceeds(): void
     {
         $this->assertEquals(
@@ -251,9 +218,106 @@ class QueryTest extends TestCase
             Query::save('test_tbl'), 'INSERT ON CONFLICT statement not constructed correctly');
     }
 
-    public function testUpdateSucceeds()
+    #[TestDox('update() succeeds')]
+    public function testUpdateSucceeds(): void
     {
         $this->assertEquals("UPDATE testing SET data = :data WHERE data->>'id' = :id", Query::update('testing'),
             'UPDATE statement not constructed correctly');
     }
+
+    #[TestDox('orderBy() succeeds with no fields for PostgreSQL')]
+    public function testOrderBySucceedsWithNoFieldsForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals('', Query::orderBy([]), 'ORDER BY should have been blank');
+    }
+
+    #[TestDox('orderBy() succeeds with no fields for SQLite')]
+    public function testOrderBySucceedsWithNoFieldsForSQLite(): void
+    {
+        $this->assertEquals('', Query::orderBy([]), 'ORDER BY should have been blank');
+    }
+
+    #[TestDox('orderBy() succeeds with one field and no direction for PostgreSQL')]
+    public function testOrderBySucceedsWithOneFieldAndNoDirectionForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals(" ORDER BY data->>'TestField'", Query::orderBy([Field::named('TestField')]),
+            'ORDER BY not constructed correctly');
+    }
+
+    #[TestDox('orderBy() succeeds with one field and no direction for SQLite')]
+    public function testOrderBySucceedsWithOneFieldAndNoDirectionForSQLite(): void
+    {
+        $this->assertEquals(" ORDER BY data->>'TestField'", Query::orderBy([Field::named('TestField')]),
+            'ORDER BY not constructed correctly');
+    }
+
+    #[TestDox('orderBy() succeeds with one qualified field for PostgreSQL')]
+    public function testOrderBySucceedsWithOneQualifiedFieldForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        $field = Field::named('TestField');
+        $field->qualifier = 'qual';
+        $this->assertEquals(" ORDER BY qual.data->>'TestField'", Query::orderBy([$field]),
+            'ORDER BY not constructed correctly');
+    }
+
+    #[TestDox('orderBy() succeeds with one qualified field for SQLite')]
+    public function testOrderBySucceedsWithOneQualifiedFieldForSQLite(): void
+    {
+        $field = Field::named('TestField');
+        $field->qualifier = 'qual';
+        $this->assertEquals(" ORDER BY qual.data->>'TestField'", Query::orderBy([$field]),
+            'ORDER BY not constructed correctly');
+    }
+
+    #[TestDox('orderBy() succeeds with multiple fields and direction for PostgreSQL')]
+    public function testOrderBySucceedsWithMultipleFieldsAndDirectionForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals(" ORDER BY data#>>'{Nested,Test,Field}' DESC, data->>'AnotherField', data->>'It' DESC",
+            Query::orderBy(
+                [Field::named('Nested.Test.Field DESC'), Field::named('AnotherField'), Field::named('It DESC')]),
+            'ORDER BY not constructed correctly');
+    }
+
+    #[TestDox('orderBy() succeeds with multiple fields and direction for SQLite')]
+    public function testOrderBySucceedsWithMultipleFieldsAndDirectionForSQLite(): void
+    {
+        $this->assertEquals(" ORDER BY data->'Nested'->'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC",
+            Query::orderBy(
+                [Field::named('Nested.Test.Field DESC'), Field::named('AnotherField'), Field::named('It DESC')]),
+            'ORDER BY not constructed correctly');
+    }
+
+    #[TestDox('orderBy() succeeds with numeric field for PostgreSQL')]
+    public function testOrderBySucceedsWithNumericFieldForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals(" ORDER BY (data->>'Test')::numeric", Query::orderBy([Field::named('n:Test')]),
+            'ORDER BY not constructed correctly');
+    }
+
+    #[TestDox('orderBy() succeeds with numeric field for SQLite')]
+    public function testOrderBySucceedsWithNumericFieldForSQLite(): void
+    {
+        $this->assertEquals(" ORDER BY data->>'Test'", Query::orderBy([Field::named('n:Test')]),
+            'ORDER BY not constructed correctly');
+    }
+
+    #[TestDox('orderBy() succeeds with case-insensitive ordering for PostgreSQL')]
+    public function testOrderBySucceedsWithCaseInsensitiveOrderingForPostgreSQL(): void
+    {
+        Configuration::overrideMode(Mode::PgSQL);
+        $this->assertEquals(" ORDER BY LOWER(data#>>'{Test,Field}') DESC NULLS FIRST",
+            Query::orderBy([Field::named('i:Test.Field DESC NULLS FIRST')]), 'ORDER BY not constructed correctly');
+    }
+
+    #[TestDox('orderBy() succeeds with case-insensitive ordering for SQLite')]
+    public function testOrderBySucceedsWithCaseInsensitiveOrderingForSQLite(): void
+    {
+        $this->assertEquals(" ORDER BY data->'Test'->>'Field' COLLATE NOCASE ASC NULLS LAST",
+            Query::orderBy([Field::named('i:Test.Field ASC NULLS LAST')]), 'ORDER BY not constructed correctly');
+    }
 }