Wip

Author: BenMorel

.docker/php/Dockerfile

@@ -53,11 +53,11 @@ SHELL ["/bin/sh", "-e", "-c"]
 
 RUN <<EOF
 apt update
-apt install --yes git libzip-dev libpq-dev libsqlite3-mod-spatialite
+apt install --yes git sqlite3 libzip-dev libpq-dev libsqlite3-mod-spatialite
 rm -rf /var/lib/apt/lists/*
 EOF
 
-RUN docker-php-ext-install opcache zip pdo pdo_pgsql pdo_mysql
+RUN docker-php-ext-install opcache zip pdo pdo_pgsql pdo_mysql pgsql
 
 # SQLite3 configuration
 RUN echo "[sqlite3]\nsqlite3.extension_dir = /usr/lib/x86_64-linux-gnu"> /usr/local/etc/php/conf.d/sqlite3.ini

README.md

@@ -188,11 +188,11 @@ all you need to do is create an additional in-memory SQLite3 database just to po
 - Use this bootstrap code in your project:
 
     ```php
-    use Brick\Geo\Engine\Sqlite3Engine;
+    use Brick\Geo\Engine\SpatialiteEngine;
 
     $sqlite3 = new SQLite3(':memory:');
     $sqlite3->loadExtension('mod_spatialite.so');
-    $geometryEngine = new Sqlite3Engine($sqlite3);
+    $geometryEngine = new SpatialiteEngine($sqlite3);
     ```
 
 - Depending on the functions you use, you will probably need to initialize the spatial metadata by running this query:

composer.json

@@ -15,7 +15,7 @@
     },
     "require-dev": {
         "ext-pdo": "*",
-        "ext-json": "*",
+        "ext-pgsql": "*",
         "ext-sqlite3": "*",
         "brick/reflection": "~0.5.0",
         "phpunit/phpunit": "^11.0",

phpunit-bootstrap.php

@@ -1,8 +1,14 @@
 <?php
 
+use Brick\Geo\Engine\Database\Driver\PdoMysqlDriver;
+use Brick\Geo\Engine\Database\Driver\PdoPgsqlDriver;
+use Brick\Geo\Engine\Database\Driver\PgsqlDriver;
+use Brick\Geo\Engine\Database\Driver\Sqlite3Driver;
 use Brick\Geo\Engine\GeosOpEngine;
-use Brick\Geo\Engine\PdoEngine;
-use Brick\Geo\Engine\Sqlite3Engine;
+use Brick\Geo\Engine\MariadbEngine;
+use Brick\Geo\Engine\MysqlEngine;
+use Brick\Geo\Engine\PostgisEngine;
+use Brick\Geo\Engine\SpatialiteEngine;
 use Brick\Geo\Engine\GeosEngine;
 
 function getOptionalEnv(string $name): ?string
@@ -43,10 +49,11 @@ function getRequiredEnv(string $name): string
         echo 'Available engines: pdo_mysql, pdo_pgsql, sqlite3, geos, geosop', PHP_EOL;
     } else {
         switch ($engine) {
-            case 'pdo_mysql':
+            // TODO reintroduce MYSQL_HOST in .env, add MARIADB_HOST
+            case 'mysql_pdo':
                 $emulatePrepares = getOptionalEnv('EMULATE_PREPARES') === 'ON';
 
-                echo 'Using PdoEngine for MySQL', PHP_EOL;
+                echo 'Using MysqlEngine', PHP_EOL;
                 echo 'with emulated prepares ', ($emulatePrepares ? 'ON' : 'OFF'), PHP_EOL;
 
                 $host = getRequiredEnv('MYSQL_HOST');
@@ -55,7 +62,7 @@ function getRequiredEnv(string $name): string
                 $password = getRequiredEnv('MYSQL_PASSWORD');
 
                 $pdo = new PDO(
-                    sprintf('mysql:host=%s;port=%d', $host, $port),
+                    sprintf('mysql:host=%s;port=%d;dbname=usertest', $host, $port), // TODO remove dbname
                     $username,
                     $password,
                     [
@@ -64,16 +71,46 @@ function getRequiredEnv(string $name): string
                     ],
                 );
 
-                $statement = $pdo->query('SELECT VERSION()');
-                $version = $statement->fetchColumn();
+                $driver = new PdoMysqlDriver($pdo);
+                $engine = new MysqlEngine($driver);
 
+                $version = $driver->executeQuery('SELECT VERSION()')->get(0)->asString();
                 echo 'MySQL version: ', $version, PHP_EOL;
 
-                $engine = new PdoEngine($pdo);
                 break;
 
-            case 'pdo_pgsql':
-                echo 'Using PdoEngine for PostgreSQL', PHP_EOL;
+            // TODO reintroduce MYSQL_HOST in .env, add MARIADB_HOST
+            case 'mariadb_pdo':
+                $emulatePrepares = getOptionalEnv('EMULATE_PREPARES') === 'ON';
+
+                echo 'Using MariadbEngine', PHP_EOL;
+                echo 'with emulated prepares ', ($emulatePrepares ? 'ON' : 'OFF'), PHP_EOL;
+
+                $host = getRequiredEnv('MYSQL_HOST');
+                $port = getOptionalEnvOrDefault('MYSQL_PORT', '3306');
+                $username = getRequiredEnv('MYSQL_USER');
+                $password = getRequiredEnv('MYSQL_PASSWORD');
+
+                $pdo = new PDO(
+                    sprintf('mysql:host=%s;port=%d;dbname=usertest', $host, $port), // TODO remove dbname
+                    $username,
+                    $password,
+                    [
+                        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+                        PDO::ATTR_EMULATE_PREPARES => $emulatePrepares,
+                    ],
+                );
+
+                $driver = new PdoMysqlDriver($pdo);
+                $engine = new MariadbEngine($driver);
+
+                $version = $driver->executeQuery('SELECT VERSION()')->get(0)->asString();
+                echo 'MySQL version: ', $version, PHP_EOL;
+
+                break;
+
+            case 'postgis_pdo':
+                echo 'Using PostgisEngine with PdoMysqlDriver', PHP_EOL;
 
                 $host = getRequiredEnv('POSTGRES_HOST');
                 $port = getOptionalEnvOrDefault('POSTGRES_PORT', '5432');
@@ -89,38 +126,66 @@ function getRequiredEnv(string $name): string
                     ],
                 );
 
+                // TODO move to docker compose
                 $pdo->exec('CREATE EXTENSION IF NOT EXISTS postgis;');
 
-                $statement = $pdo->query('SELECT version()');
-                $version = $statement->fetchColumn();
+                $driver = new PdoPgsqlDriver($pdo);
+                $engine = new PostgisEngine($driver);
 
+                $version = $driver->executeQuery('SELECT version()')->get(0)->asString();
                 echo 'PostgreSQL version: ', $version, PHP_EOL;
 
-                $statement = $pdo->query('SELECT PostGIS_Full_Version()');
-                $version = $statement->fetchColumn();
+                $version = $driver->executeQuery('SELECT PostGIS_Full_Version()')->get(0)->asString();
+                echo 'PostGIS version: ', $version, PHP_EOL;
+
+                break;
+
+            case 'postgis_pgsql':
+                echo 'Using PostgisEngine with PgsqlDriver', PHP_EOL;
 
+                $host = getRequiredEnv('POSTGRES_HOST');
+                $port = getOptionalEnvOrDefault('POSTGRES_PORT', '5432');
+                $username = getRequiredEnv('POSTGRES_USER');
+                $password = getRequiredEnv('POSTGRES_PASSWORD');
+
+                $connection = pg_connect(sprintf(
+                    'host=%s port=%d user=%s password=%s',
+                    $host,
+                    $port,
+                    $username,
+                    $password,
+                ));
+
+                $driver = new PgsqlDriver($connection);
+                $engine = new PostgisEngine($driver);
+
+                $version = $driver->executeQuery('SELECT version()')->get(0)->asString();
+                echo 'PostgreSQL version: ', $version, PHP_EOL;
+
+                $version = $driver->executeQuery('SELECT PostGIS_Full_Version()')->get(0)->asString();
                 echo 'PostGIS version: ', $version, PHP_EOL;
 
-                $engine = new PdoEngine($pdo);
                 break;
 
-            case 'sqlite3':
-                echo 'Using Sqlite3Engine', PHP_EOL;
+            case 'spatialite_sqlite3':
+                echo 'Using SpatialiteEngine', PHP_EOL;
 
                 $sqlite3 = new SQLite3(':memory:');
                 $sqlite3->enableExceptions(true);
 
-                $sqliteVersion = $sqlite3->querySingle('SELECT sqlite_version()');
+                $driver = new Sqlite3Driver($sqlite3);
+
+                $sqliteVersion = $driver->executeQuery('SELECT sqlite_version()')->get(0)->asString();
                 echo 'SQLite version: ', $sqliteVersion, PHP_EOL;
 
                 $sqlite3->loadExtension('mod_spatialite.so');
 
-                $spatialiteVersion = $sqlite3->querySingle('SELECT spatialite_version()');
+                $spatialiteVersion = $driver->executeQuery('SELECT spatialite_version()')->get(0)->asString();
                 echo 'SpatiaLite version: ', $spatialiteVersion, PHP_EOL;
 
                 $sqlite3->exec('SELECT InitSpatialMetaData()');
 
-                $engine = new Sqlite3Engine($sqlite3);
+                $engine = new SpatialiteEngine($driver);
                 break;
 
             case 'geos':

src/Engine/Database/DatabaseDriver.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine\Database;
+
+use Brick\Geo\Engine\Database\Query\BinaryValue;
+use Brick\Geo\Engine\Database\Query\ScalarValue;
+use Brick\Geo\Engine\Database\Result\Row;
+use Brick\Geo\Exception\GeometryEngineException;
+
+interface DatabaseDriver
+{
+    /**
+     * Executes a SQL query and returns exactly one row.
+     *
+     * Accepts one or more query components where each element can be:
+     * - a string (inserted directly into the query),
+     * - a BinaryValue or ScalarValue instance (typically replaced with a placeholder
+     *   and bound as a prepared statement parameter).
+     *
+     * Example: executeQuery('SELECT ST_Length(ST_GeomFromEWKB(', new BinaryValue($ewkb), '))')
+     *
+     * @throws GeometryEngineException If the query fails, or if the result is not exactly one row.
+     */
+    public function executeQuery(string|BinaryValue|ScalarValue ...$query) : Row;
+
+    /**
+     * @throws GeometryEngineException
+     */
+    public function convertBinaryResult(mixed $value) : string;
+
+    /**
+     * @throws GeometryEngineException
+     */
+    public function convertStringResult(mixed $value) : string;
+
+    /**
+     * @throws GeometryEngineException
+     */
+    public function convertIntResult(mixed $value) : int;
+
+    /**
+     * @throws GeometryEngineException
+     */
+    public function convertFloatResult(mixed $value) : float;
+
+    /**
+     * @throws GeometryEngineException
+     */
+    public function convertBoolResult(mixed $value) : bool;
+}

src/Engine/Database/Driver/PdoMysqlDriver.php

@@ -0,0 +1,129 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine\Database\Driver;
+
+use Brick\Geo\Engine\Database\DatabaseDriver;
+use Brick\Geo\Engine\Database\Query\BinaryValue;
+use Brick\Geo\Engine\Database\Query\ScalarValue;
+use Brick\Geo\Engine\Database\Result\Row;
+use Brick\Geo\Exception\GeometryEngineException;
+use Override;
+use PDO;
+use PDOException;
+use PDOStatement;
+
+/**
+ * Database driver using a pdo_mysql connection.
+ */
+final class PdoMysqlDriver implements DatabaseDriver
+{
+    public function __construct(
+        private readonly PDO $pdo,
+    ) {
+    }
+
+    #[Override]
+    public function executeQuery(string|BinaryValue|ScalarValue ...$query) : Row
+    {
+        $queryString = '';
+        $queryParams = [];
+
+        foreach ($query as $queryPart) {
+            if ($queryPart instanceof BinaryValue) {
+                $queryString .= 'BINARY ?';
+                $queryParams[] = [$queryPart->value, PDO::PARAM_LOB];
+            } elseif ($queryPart instanceof ScalarValue) {
+                $queryString .= '?';
+
+                if (is_int($queryPart->value)) {
+                    $queryParams[] = [$queryPart->value, PDO::PARAM_INT];
+                } elseif (is_bool($queryPart->value)) {
+                    $queryParams[] = [$queryPart->value, PDO::PARAM_BOOL];
+                } else {
+                    $queryParams[] = [$queryPart->value, PDO::PARAM_STR];
+                }
+            } else {
+                $queryString .= $queryPart;
+            }
+        }
+
+        /** @var int $errMode */
+        $errMode = $this->pdo->getAttribute(PDO::ATTR_ERRMODE);
+        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+
+        try {
+            $statement = $this->pdo->prepare($queryString);
+
+            $position = 1;
+
+            foreach ($queryParams as [$value, $type]) {
+                $statement->bindValue($position++, $value, $type);
+            }
+
+            $statement->execute();
+
+            /** @var list<list<mixed>> $result */
+            $result = $statement->fetchAll(PDO::FETCH_NUM);
+        } catch (PDOException $e) {
+            throw GeometryEngineException::wrap($e);
+        } finally {
+            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, $errMode);
+        }
+
+        if (count($result) !== 1) {
+            throw new GeometryEngineException(sprintf('Expected exactly one row, got %d.', count($result)));
+        }
+
+        return new Row($this, $result[0]);
+    }
+
+    public function convertBinaryResult(mixed $value) : string
+    {
+        if (is_string($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('string', $value);
+    }
+
+    public function convertStringResult(mixed $value) : string
+    {
+        if (is_string($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('string', $value);
+    }
+
+    public function convertIntResult(mixed $value) : int
+    {
+        // TODO check that actually returned as int;
+        //      maybe checks for all types sent & received for each driver?
+
+        if (is_int($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('int', $value);
+    }
+
+    public function convertFloatResult(mixed $value) : float
+    {
+        if (is_numeric($value)) {
+            return (float) $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('number or numeric string', $value);
+    }
+
+    public function convertBoolResult(mixed $value) : bool
+    {
+        return match ($value) {
+            0 => false,
+            1 => true,
+            default => throw GeometryEngineException::unexpectedDatabaseReturnType('0 or 1', $value),
+        };
+    }
+}

src/Engine/Database/Driver/PdoPgsqlDriver.php

@@ -0,0 +1,132 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine\Database\Driver;
+
+use Brick\Geo\Engine\Database\DatabaseDriver;
+use Brick\Geo\Engine\Database\Query\BinaryValue;
+use Brick\Geo\Engine\Database\Query\ScalarValue;
+use Brick\Geo\Engine\Database\Result\Row;
+use Brick\Geo\Exception\GeometryEngineException;
+use Override;
+use PDO;
+use PDOException;
+
+/**
+ * Database driver using a pdo_pgsql connection.
+ */
+final class PdoPgsqlDriver implements DatabaseDriver
+{
+    public function __construct(
+        private readonly PDO $pdo,
+    ) {
+    }
+
+    #[Override]
+    public function executeQuery(string|BinaryValue|ScalarValue ...$query) : Row
+    {
+        $queryString = '';
+        $queryParams = [];
+
+        foreach ($query as $queryPart) {
+            if ($queryPart instanceof BinaryValue) {
+                $queryString .= '?';
+                $queryParams[] = [$queryPart->value, PDO::PARAM_LOB];
+            } elseif ($queryPart instanceof ScalarValue) {
+                $queryString .= '?';
+
+                if (is_int($queryPart->value)) {
+                    $queryString .= '::int'; // PARAM_INT seems to have no effect on pdo_pgsql
+                    $queryParams[] = [$queryPart->value, PDO::PARAM_INT];
+                } elseif (is_float($queryPart->value)) {
+                    $queryString .= '::float';
+                    $queryParams[] = [$queryPart->value, PDO::PARAM_STR];
+                } elseif (is_bool($queryPart->value)) {
+                    $queryParams[] = [$queryPart->value, PDO::PARAM_BOOL];
+                } else {
+                    $queryParams[] = [$queryPart->value, PDO::PARAM_STR];
+                }
+            } else {
+                $queryString .= $queryPart;
+            }
+        }
+
+        /** @var int $errMode */
+        $errMode = $this->pdo->getAttribute(PDO::ATTR_ERRMODE);
+        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+
+        try {
+            $statement = $this->pdo->prepare($queryString);
+
+            $position = 1;
+
+            foreach ($queryParams as [$value, $type]) {
+                $statement->bindValue($position++, $value, $type);
+            }
+
+            $statement->execute();
+
+            /** @var list<list<mixed>> $result */
+            $result = $statement->fetchAll(PDO::FETCH_NUM);
+        } catch (PDOException $e) {
+            throw GeometryEngineException::wrap($e);
+        } finally {
+            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, $errMode);
+        }
+
+        if (count($result) !== 1) {
+            throw new GeometryEngineException(sprintf('Expected exactly one row, got %d.', count($result)));
+        }
+
+        return new Row($this, $result[0]);
+    }
+
+    public function convertBinaryResult(mixed $value) : string
+    {
+        if (is_resource($value)) {
+            return stream_get_contents($value);
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('resource', $value);
+    }
+
+    public function convertStringResult(mixed $value) : string
+    {
+        if (is_string($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('string', $value);
+    }
+
+    public function convertIntResult(mixed $value) : int
+    {
+        // TODO check that actually returned as int;
+        //      maybe checks for all types sent & received for each driver?
+
+        if (is_int($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('int', $value);
+    }
+
+    public function convertFloatResult(mixed $value) : float
+    {
+        if (is_numeric($value)) {
+            return (float) $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('number or numeric string', $value);
+    }
+
+    public function convertBoolResult(mixed $value) : bool
+    {
+        if (is_bool($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('bool', $value);
+    }
+}

src/Engine/Database/Driver/PgsqlDriver.php

@@ -0,0 +1,134 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine\Database\Driver;
+
+use Brick\Geo\Engine\Database\DatabaseDriver;
+use Brick\Geo\Engine\Database\Query\BinaryValue;
+use Brick\Geo\Engine\Database\Query\ScalarValue;
+use Brick\Geo\Engine\Database\Result\Row;
+use Brick\Geo\Exception\GeometryEngineException;
+use Override;
+use PgSql\Connection;
+
+/**
+ * Database driver using the pgsql extension for PostgreSQL.
+ *
+ * TODO error handling!
+ */
+final class PgsqlDriver implements DatabaseDriver
+{
+    public function __construct(
+        private readonly Connection $connection,
+    ) {
+    }
+
+    #[Override]
+    public function executeQuery(string|BinaryValue|ScalarValue ...$query) : Row
+    {
+        $position = 1;
+
+        $queryString = '';
+        $queryParams = [];
+
+        foreach ($query as $queryPart) {
+            if ($queryPart instanceof BinaryValue) {
+                $queryString .= '$' . $position++ . '::bytea';
+                $queryParams[] = pg_escape_bytea($this->connection, $queryPart->value);
+            } elseif ($queryPart instanceof ScalarValue) {
+                $queryString .= '$' . $position++;
+
+                if (is_int($queryPart->value)) {
+                    $queryString .= '::int';
+                    $queryParams[] = $queryPart->value;
+                } elseif (is_float($queryPart->value)) {
+                    $queryString .= '::float';
+                    $queryParams[] = $queryPart->value;
+                } elseif (is_bool($queryPart->value)) {
+                    $queryString .= '::bool';
+                    $queryParams[] = $queryPart->value ? 't' : 'f';
+                } else {
+                    $queryParams[] = $queryPart->value;
+                }
+            } else {
+                $queryString .= $queryPart;
+            }
+        }
+
+        $value = pg_prepare($this->connection, '', $queryString);
+
+        if ($value === false) {
+            die(pg_last_error());
+        }
+
+        $result = pg_execute($this->connection, '', $queryParams);
+
+        if ($result === false) {
+            var_dump($queryParams);
+            var_dump(pg_last_error($this->connection));
+            die;
+        }
+
+        /** @var list<list<mixed>> $rows */
+        $rows = pg_fetch_all($result, PGSQL_NUM);
+
+        if ($rows === false) {
+            die(pg_last_error());
+        }
+
+        if (count($rows) !== 1) {
+            throw new GeometryEngineException(sprintf('Expected exactly one row, got %d.', count($rows)));
+        }
+
+        return new Row($this, $rows[0]);
+    }
+
+    public function convertBinaryResult(mixed $value) : string
+    {
+        if (is_string($value)) {
+            return pg_unescape_bytea($value);
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('string', $value);
+    }
+
+    public function convertStringResult(mixed $value) : string
+    {
+        if (is_string($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('string', $value);
+    }
+
+    public function convertIntResult(mixed $value) : int
+    {
+        // TODO check that actually returned as int;
+        //      maybe checks for all types sent & received for each driver?
+
+        if (is_int($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('int', $value);
+    }
+
+    public function convertFloatResult(mixed $value) : float
+    {
+        if (is_numeric($value)) {
+            return (float) $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('number or numeric string', $value);
+    }
+
+    public function convertBoolResult(mixed $value) : bool
+    {
+        return match ($value) {
+            't' => true,
+            'f' => false,
+            default => throw GeometryEngineException::unexpectedDatabaseReturnType('t or f', $value),
+        };
+    }
+}

src/Engine/Database/Driver/Sqlite3Driver.php

@@ -0,0 +1,129 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine\Database\Driver;
+
+use Brick\Geo\Engine\Database\DatabaseDriver;
+use Brick\Geo\Engine\Database\Query\BinaryValue;
+use Brick\Geo\Engine\Database\Query\ScalarValue;
+use Brick\Geo\Engine\Database\Result\Row;
+use Brick\Geo\Exception\GeometryEngineException;
+use Override;
+use SQLite3;
+
+/**
+ * Database driver using an SQLite3 connection.
+ */
+class Sqlite3Driver implements DatabaseDriver
+{
+    public function __construct(
+        private SQLite3 $sqlite3,
+    ) {
+    }
+
+    #[Override]
+    public function executeQuery(string|BinaryValue|ScalarValue ...$query) : Row
+    {
+        $queryString = '';
+        $queryParams = [];
+
+        foreach ($query as $queryPart) {
+            if ($queryPart instanceof BinaryValue) {
+                $queryString .= '?';
+                $queryParams[] = [$queryPart->value, SQLITE3_BLOB];
+            } elseif ($queryPart instanceof ScalarValue) {
+                $queryString .= '?';
+
+                if (is_float($queryPart->value)) {
+                    $queryParams[] = [$queryPart->value, SQLITE3_FLOAT];
+                } elseif (is_int($queryPart->value) || is_bool($queryPart->value)) {
+                    $queryParams[] = [$queryPart->value, SQLITE3_INTEGER];
+                } else {
+                    $queryParams[] = [$queryPart->value, SQLITE3_TEXT];
+                }
+            } else {
+                $queryString .= $queryPart;
+            }
+        }
+
+        $enableExceptions = $this->sqlite3->enableExceptions(true);
+
+        try {
+            $statement = $this->sqlite3->prepare($queryString);
+
+            $position = 1;
+
+            foreach ($queryParams as [$value, $type]) {
+                $statement->bindValue($position++, $value, $type);
+            }
+
+            $sqlite3Result = $statement->execute();
+
+            $result = [];
+
+            while (false !== $row = $sqlite3Result->fetchArray(SQLITE3_NUM)) {
+                $result[] = $row;
+            }
+
+        } catch (\Exception $e) {
+            throw GeometryEngineException::wrap($e);
+        } finally {
+            $this->sqlite3->enableExceptions($enableExceptions);
+        }
+
+        if (count($result) !== 1) {
+            throw new GeometryEngineException(sprintf('Expected exactly one row, got %d.', count($result)));
+        }
+
+        return new Row($this, $result[0]);
+    }
+
+    public function convertBinaryResult(mixed $value) : string
+    {
+        if (is_string($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('string', $value);
+    }
+
+    public function convertStringResult(mixed $value) : string
+    {
+        if (is_string($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('string', $value);
+    }
+
+    public function convertIntResult(mixed $value) : int
+    {
+        // TODO check that actually returned as int;
+        //      maybe checks for all types sent & received for each driver?
+
+        if (is_int($value)) {
+            return $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('int', $value);
+    }
+
+    public function convertFloatResult(mixed $value) : float
+    {
+        if (is_numeric($value)) {
+            return (float) $value;
+        }
+
+        throw GeometryEngineException::unexpectedDatabaseReturnType('number or numeric string', $value);
+    }
+
+    public function convertBoolResult(mixed $value) : bool
+    {
+        return match ($value) {
+            0 => false,
+            1 => true,
+            default => throw GeometryEngineException::unexpectedDatabaseReturnType('t or f', $value),
+        };
+    }
+}

src/Engine/Database/Query/BinaryValue.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine\Database\Query;
+
+/**
+ * Marker class for passing binary data to the database.
+ */
+final readonly class BinaryValue
+{
+    public function __construct(
+        public string $value,
+    ) {
+    }
+}

src/Engine/Database/Query/ScalarValue.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine\Database\Query;
+
+/**
+ * Marker class for passing scalar values to the database.
+ */
+final readonly class ScalarValue
+{
+    /**
+     * @param scalar $value
+     */
+    public function __construct(
+        public mixed $value,
+    ) {
+    }
+}

src/Engine/Database/Result/Row.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine\Database\Result;
+
+use Brick\Geo\Engine\Database\DatabaseDriver;
+use Brick\Geo\Exception\GeometryEngineException;
+
+final readonly class Row
+{
+    /**
+     * @param list<mixed> $values
+     */
+    public function __construct(
+        private DatabaseDriver $driver,
+        private array $values,
+    ) {
+    }
+
+    public function get(int $index) : Value
+    {
+        if (! array_key_exists($index, $this->values)) {
+            throw new GeometryEngineException(sprintf('Column %d not found in Result.', $index));
+        }
+
+        return new Value($this->driver, $this->values[$index]);
+    }
+}

src/Engine/Database/Result/Value.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine\Database\Result;
+
+use Brick\Geo\Engine\Database\DatabaseDriver;
+
+final readonly class Value
+{
+    public function __construct(
+        private DatabaseDriver $driver,
+        private mixed $value,
+    ) {
+    }
+
+    public function asBinary() : string
+    {
+        return $this->driver->convertBinaryResult($this->value);
+    }
+
+    public function asString() : string
+    {
+        return $this->driver->convertStringResult($this->value);
+    }
+
+    public function asInt() : int
+    {
+        return $this->driver->convertIntResult($this->value);
+    }
+
+    public function asFloat() : float
+    {
+        return $this->driver->convertFloatResult($this->value);
+    }
+
+    public function asBool() : bool
+    {
+        return $this->driver->convertBoolResult($this->value);
+    }
+}

src/Engine/DatabaseEngine.php

@@ -5,128 +5,24 @@
 namespace Brick\Geo\Engine;
 
 use Brick\Geo\Curve;
+use Brick\Geo\Engine\Database\DatabasePlatform;
+use Brick\Geo\Engine\Internal\GeometryParameter;
 use Brick\Geo\Engine\Internal\TypeChecker;
 use Brick\Geo\Exception\GeometryEngineException;
 use Brick\Geo\Geometry;
 use Brick\Geo\LineString;
 use Brick\Geo\MultiCurve;
 use Brick\Geo\MultiPoint;
 use Brick\Geo\MultiSurface;
-use Brick\Geo\MultiPolygon;
 use Brick\Geo\Point;
-use Brick\Geo\Polygon;
-use Brick\Geo\Proxy;
-use Brick\Geo\Proxy\ProxyInterface;
 use Brick\Geo\Surface;
 use Override;
 
 /**
- * Database implementation of the GeometryEngine.
- *
- * The target database must have support for GIS functions.
+ * Base class for database engines.
  */
-abstract class DatabaseEngine implements GeometryEngine
+abstract readonly class DatabaseEngine implements GeometryEngine
 {
-    private readonly bool $useProxy;
-
-    public function __construct(bool $useProxy)
-    {
-        $this->useProxy = $useProxy;
-    }
-
-    /**
-     * Executes a SQL query.
-     *
-     * @param string                         $query      The SQL query to execute.
-     * @param list<GeometryParameter|scalar> $parameters The geometry data or scalar values to pass as parameters.
-     *
-     * @return list<mixed> A numeric result array.
-     *
-     * @throws GeometryEngineException
-     */
-    abstract protected function executeQuery(string $query, array $parameters) : array;
-
-    /**
-     * Returns the syntax required to perform a ST_GeomFromText(), together with placeholders.
-     *
-     * This method may be overridden if necessary.
-     */
-    protected function getGeomFromTextSyntax(): string
-    {
-        return 'ST_GeomFromText(?, ?)';
-    }
-
-    /**
-     * Returns the syntax required to perform a ST_GeomFromWKB(), together with placeholders.
-     *
-     * This method may be overridden if necessary.
-     */
-    protected function getGeomFromWkbSyntax(): string
-    {
-        return 'ST_GeomFromWKB(?, ?)';
-    }
-
-    /**
-     * Returns the placeholder syntax for the given parameter.
-     *
-     * This method may be overridden to perform explicit type casts if necessary.
-     */
-    protected function getParameterPlaceholder(string|float|int|bool $parameter): string
-    {
-        return '?';
-    }
-
-    /**
-     * Builds and executes a SQL query for a GIS function.
-     *
-     * @param string                 $function        The SQL GIS function to execute.
-     * @param array<Geometry|scalar> $parameters      The Geometry objects or scalar values to pass as parameters.
-     * @param bool                   $returnsGeometry Whether the GIS function returns a Geometry.
-     *
-     * @return list<mixed> A numeric result array.
-     *
-     * @throws GeometryEngineException
-     */
-    private function query(string $function, array $parameters, bool $returnsGeometry) : array
-    {
-        $queryParameters = [];
-        $queryValues = [];
-
-        foreach ($parameters as $parameter) {
-            if ($parameter instanceof Geometry) {
-                if ($parameter instanceof Proxy\ProxyInterface) {
-                    $sendAsBinary = $parameter->isProxyBinary();
-                } else {
-                    $sendAsBinary = ! $parameter->isEmpty();
-                }
-
-                $queryParameters[] = $sendAsBinary
-                    ? $this->getGeomFromWkbSyntax()
-                    : $this->getGeomFromTextSyntax();
-
-                $queryValues[] = new GeometryParameter($parameter, $sendAsBinary);
-            } else {
-                $queryParameters[] = $this->getParameterPlaceholder($parameter);
-                $queryValues[] = $parameter;
-            }
-        }
-
-        $query = sprintf('SELECT %s(%s)', $function, implode(', ', $queryParameters));
-
-        if ($returnsGeometry) {
-            $query = sprintf('
-                SELECT
-                    CASE WHEN ST_IsEmpty(g) THEN ST_AsText(g) ELSE NULL END,
-                    CASE WHEN ST_IsEmpty(g) THEN NULL ELSE ST_AsBinary(g) END,
-                    ST_GeometryType(g),
-                    ST_SRID(g)
-                FROM (%s AS g) AS q
-            ', $query);
-        }
-
-        return $this->executeQuery($query, $queryValues);
-    }
-
     /**
      * Queries a GIS function returning a boolean value.
      *
@@ -135,21 +31,7 @@ private function query(string $function, array $parameters, bool $returnsGeometr
      *
      * @throws GeometryEngineException
      */
-    private function queryBoolean(string $function, Geometry|string|float|int|bool ...$parameters) : bool
-    {
-        /** @var array{scalar|null} $result */
-        $result = $this->query($function, $parameters, false);
-
-        $value = $result[0];
-
-        // SQLite3 returns -1 when calling a boolean GIS function on a NULL result,
-        // MariaDB returns -1 when an unsupported operation is performed on a Z/M geometry.
-        if ($value === null || $value === -1 || $value === '-1') {
-            throw GeometryEngineException::operationYieldedNoResult();
-        }
-
-        return (bool) $value;
-    }
+    abstract protected function queryBool(string $function, Geometry|string|float|int|bool ...$parameters) : bool;
 
     /**
      * Queries a GIS function returning a floating point value.
@@ -159,19 +41,7 @@ private function queryBoolean(string $function, Geometry|string|float|int|bool .
      *
      * @throws GeometryEngineException
      */
-    private function queryFloat(string $function, Geometry|string|float|int|bool ...$parameters) : float
-    {
-        /** @var array{scalar|null} $result */
-        $result = $this->query($function, $parameters, false);
-
-        $value = $result[0];
-
-        if ($value === null) {
-            throw GeometryEngineException::operationYieldedNoResult();
-        }
-
-        return (float) $value;
-    }
+    abstract protected function queryFloat(string $function, Geometry|string|float|int|bool ...$parameters) : float;
 
     /**
      * Queries a GIS function returning a Geometry object.
@@ -181,94 +51,18 @@ private function queryFloat(string $function, Geometry|string|float|int|bool ...
      *
      * @throws GeometryEngineException
      */
-    final protected function queryGeometry(string $function, Geometry|string|float|int|bool ...$parameters) : Geometry
-    {
-        /** @var array{string|null, string|resource|null, string, int|numeric-string} $result */
-        $result = $this->query($function, $parameters, true);
-
-        [$wkt, $wkb, $geometryType, $srid] = $result;
-
-        $srid = (int) $srid;
-
-        if ($wkt !== null) {
-            if ($this->useProxy) {
-                $proxyClassName = $this->getProxyClassName($geometryType);
-
-                return new $proxyClassName($wkt, false, $srid);
-            }
-
-            return Geometry::fromText($wkt, $srid);
-        }
-
-        if ($wkb !== null) {
-            if (is_resource($wkb)) {
-                $wkb = stream_get_contents($wkb);
-            }
-
-            if ($this->useProxy) {
-                $proxyClassName = $this->getProxyClassName($geometryType);
-
-                return new $proxyClassName($wkb, true, $srid);
-            }
-
-            return Geometry::fromBinary($wkb, $srid);
-        }
-
-        throw GeometryEngineException::operationYieldedNoResult();
-    }
-
-    /**
-     * @return class-string<Proxy\ProxyInterface&Geometry>
-     *
-     * @throws GeometryEngineException
-     */
-    private function getProxyClassName(string $geometryType) : string
-    {
-        $proxyClasses = [
-            'CIRCULARSTRING'     => Proxy\CircularStringProxy::class,
-            'COMPOUNDCURVE'      => Proxy\CompoundCurveProxy::class,
-            'CURVE'              => Proxy\CurveProxy::class,
-            'CURVEPOLYGON'       => Proxy\CurvePolygonProxy::class,
-            'GEOMCOLLECTION'     => Proxy\GeometryCollectionProxy::class, /* MySQL 8 - https://github.com/brick/geo/pull/33 */
-            'GEOMETRY'           => Proxy\GeometryProxy::class,
-            'GEOMETRYCOLLECTION' => Proxy\GeometryCollectionProxy::class,
-            'LINESTRING'         => Proxy\LineStringProxy::class,
-            'MULTICURVE'         => Proxy\MultiCurveProxy::class,
-            'MULTILINESTRING'    => Proxy\MultiLineStringProxy::class,
-            'MULTIPOINT'         => Proxy\MultiPointProxy::class,
-            'MULTIPOLYGON'       => Proxy\MultiPolygonProxy::class,
-            'MULTISURFACE'       => Proxy\MultiSurfaceProxy::class,
-            'POINT'              => Proxy\PointProxy::class,
-            'POLYGON'            => Proxy\PolygonProxy::class,
-            'POLYHEDRALSURFACE'  => Proxy\PolyhedralSurfaceProxy::class,
-            'SURFACE'            => Proxy\SurfaceProxy::class,
-            'TIN'                => Proxy\TinProxy::class,
-            'TRIANGLE'           => Proxy\TriangleProxy::class
-        ];
-
-        $geometryType = strtoupper($geometryType);
-        $geometryType = preg_replace('/^ST_/', '', $geometryType);
-        assert($geometryType !== null);
-        $geometryType = preg_replace('/ .*/', '', $geometryType);
-        assert($geometryType !== null);
-
-        if (! isset($proxyClasses[$geometryType])) {
-            throw new GeometryEngineException('Unknown geometry type: ' . $geometryType);
-        }
-
-        return $proxyClasses[$geometryType];
-    }
+    abstract protected function queryGeometry(string $function, Geometry|string|float|int|bool ...$parameters) : Geometry;
 
     #[Override]
     public function contains(Geometry $a, Geometry $b) : bool
     {
-        return $this->queryBoolean('ST_Contains', $a, $b);
+        return $this->queryBool('ST_Contains', $a, $b);
     }
 
     #[Override]
     public function intersects(Geometry $a, Geometry $b) : bool
     {
-        return $this->queryBoolean('ST_Intersects', $a, $b);
+        return $this->queryBool('ST_Intersects', $a, $b);
     }
 
     #[Override]
@@ -340,30 +134,25 @@ public function boundary(Geometry $g) : Geometry
     #[Override]
     public function isValid(Geometry $g) : bool
     {
-        return $this->queryBoolean('ST_IsValid', $g);
+        return $this->queryBool('ST_IsValid', $g);
     }
 
     #[Override]
     public function isClosed(Geometry $g) : bool
     {
-        return $this->queryBoolean('ST_IsClosed', $g);
+        return $this->queryBool('ST_IsClosed', $g);
     }
 
     #[Override]
     public function isSimple(Geometry $g) : bool
     {
-        return $this->queryBoolean('ST_IsSimple', $g);
+        return $this->queryBool('ST_IsSimple', $g);
     }
 
     #[Override]
     public function isRing(Curve $curve) : bool
     {
-        try {
-            return $this->queryBoolean('ST_IsRing', $curve);
-        } catch (GeometryEngineException) {
-            // Not all RDBMS (hello, MySQL) support ST_IsRing(), but we have an easy fallback
-            return $this->isClosed($curve) && $this->isSimple($curve);
-        }
+        return $this->queryBool('ST_IsRing', $curve);
     }
 
     #[Override]
@@ -375,43 +164,43 @@ public function makeValid(Geometry $g) : Geometry
     #[Override]
     public function equals(Geometry $a, Geometry $b) : bool
     {
-        return $this->queryBoolean('ST_Equals', $a, $b);
+        return $this->queryBool('ST_Equals', $a, $b);
     }
 
     #[Override]
     public function disjoint(Geometry $a, Geometry $b) : bool
     {
-        return $this->queryBoolean('ST_Disjoint', $a, $b);
+        return $this->queryBool('ST_Disjoint', $a, $b);
     }
 
     #[Override]
     public function touches(Geometry $a, Geometry $b) : bool
     {
-        return $this->queryBoolean('ST_Touches', $a, $b);
+        return $this->queryBool('ST_Touches', $a, $b);
     }
 
     #[Override]
     public function crosses(Geometry $a, Geometry $b) : bool
     {
-        return $this->queryBoolean('ST_Crosses', $a, $b);
+        return $this->queryBool('ST_Crosses', $a, $b);
     }
 
     #[Override]
     public function within(Geometry $a, Geometry $b) : bool
     {
-        return $this->queryBoolean('ST_Within', $a, $b);
+        return $this->queryBool('ST_Within', $a, $b);
     }
 
     #[Override]
     public function overlaps(Geometry $a, Geometry $b) : bool
     {
-        return $this->queryBoolean('ST_Overlaps', $a, $b);
+        return $this->queryBool('ST_Overlaps', $a, $b);
     }
 
     #[Override]
     public function relate(Geometry $a, Geometry $b, string $matrix) : bool
     {
-        return $this->queryBoolean('ST_Relate', $a, $b, $matrix);
+        return $this->queryBool('ST_Relate', $a, $b, $matrix);
     }
 
     #[Override]

src/Engine/GeometryParameter.php

@@ -0,0 +1,170 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine;
+
+use Brick\Geo\Engine\Database\DatabaseDriver;
+use Brick\Geo\Engine\Database\Query\BinaryValue;
+use Brick\Geo\Engine\Database\Query\ScalarValue;
+use Brick\Geo\Engine\Database\Result\Row;
+use Brick\Geo\Exception\GeometryEngineException;
+use Brick\Geo\Geometry;
+use Brick\Geo\Io\WkbReader;
+use Brick\Geo\Io\WkbWriter;
+use Override;
+
+/**
+ * Database engine based on MariaDB.
+ */
+final readonly class MariadbEngine extends DatabaseEngine
+{
+    private WkbReader $wkbReader;
+    private WkbWriter $wkbWriter;
+
+    public function __construct(
+        // TODO private
+        public DatabaseDriver $driver,
+        // TODO
+        private bool $useProxy = true,
+    ) {
+        $this->wkbReader = new WkbReader();
+        $this->wkbWriter = new WkbWriter();
+    }
+
+    /**
+     * Builds and executes a SQL query for a GIS function.
+     *
+     * @param string                $function        The SQL GIS function to execute.
+     * @param list<Geometry|scalar> $parameters      The Geometry objects or scalar values to pass as parameters.
+     * @param bool                  $returnsGeometry Whether the GIS function returns a Geometry.
+     *
+     * @throws GeometryEngineException
+     */
+    private function query(string $function, array $parameters, bool $returnsGeometry) : Row
+    {
+        $query = ['SELECT '];
+
+        if ($returnsGeometry) {
+            $query[] = 'ST_AsWKB(g), ST_SRID(g) FROM (SELECT ';
+        }
+
+        $query[] = $function . '(';
+
+        foreach ($parameters as $key => $parameter) {
+            if ($key !== 0) {
+                $query[] = ',';
+            }
+
+            if ($parameter instanceof Geometry) {
+                if ($parameter->isEmpty() && $parameter->geometryType() !== 'GeometryCollection') {
+                    throw new GeometryEngineException('TODO'); // TODO Error message
+                }
+                $query[] = 'ST_GeomFromWKB(';
+                $query[] = new BinaryValue($this->wkbWriter->write($parameter));
+                $query[] = ',';
+                $query[] = new ScalarValue($parameter->srid());
+                $query[] = ')';
+            } else {
+                $query[] = new ScalarValue($parameter);
+            }
+        }
+
+        $query[] = ')';
+
+        if ($returnsGeometry) {
+            $query[] = ' AS g) AS q';
+        }
+
+        return $this->driver->executeQuery(...$query);
+    }
+
+    /**
+     * Queries a GIS function returning a boolean value.
+     *
+     * @param string          $function      The SQL GIS function to execute.
+     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
+     *
+     * @throws GeometryEngineException
+     */
+    #[Override]
+    protected function queryBool(string $function, Geometry|string|float|int|bool ...$parameters) : bool
+    {
+        return $this->query($function, $parameters, false)->get(0)->asBool();
+    }
+
+    /**
+     * Queries a GIS function returning a floating point value.
+     *
+     * @param string          $function      The SQL GIS function to execute.
+     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
+     *
+     * @throws GeometryEngineException
+     */
+    #[Override]
+    protected function queryFloat(string $function, Geometry|string|float|int|bool ...$parameters) : float
+    {
+        return $this->query($function, $parameters, false)->get(0)->asFloat();
+    }
+
+    /**
+     * Queries a GIS function returning a Geometry object.
+     *
+     * @param string             $function   The SQL GIS function to execute.
+     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
+     *
+     * @throws GeometryEngineException
+     */
+    #[Override]
+    protected function queryGeometry(string $function, Geometry|string|float|int|bool ...$parameters) : Geometry
+    {
+        $row = $this->query($function, $parameters, true);
+
+        $wkb = $row->get(0)->asBinary();
+        $srid = $row->get(1)->asInt();
+
+        return $this->wkbReader->read($wkb, $srid);
+    }
+
+//    /**
+//     * @return class-string<Proxy\ProxyInterface&Geometry>
+//     *
+//     * @throws GeometryEngineException
+//     */
+//    private function getProxyClassName(string $geometryType) : string
+//    {
+//        $proxyClasses = [
+//            'CIRCULARSTRING'     => Proxy\CircularStringProxy::class,
+//            'COMPOUNDCURVE'      => Proxy\CompoundCurveProxy::class,
+//            'CURVE'              => Proxy\CurveProxy::class,
+//            'CURVEPOLYGON'       => Proxy\CurvePolygonProxy::class,
+//            'GEOMCOLLECTION'     => Proxy\GeometryCollectionProxy::class, /* MySQL 8 - https://github.com/brick/geo/pull/33 */
+//            'GEOMETRY'           => Proxy\GeometryProxy::class,
+//            'GEOMETRYCOLLECTION' => Proxy\GeometryCollectionProxy::class,
+//            'LINESTRING'         => Proxy\LineStringProxy::class,
+//            'MULTICURVE'         => Proxy\MultiCurveProxy::class,
+//            'MULTILINESTRING'    => Proxy\MultiLineStringProxy::class,
+//            'MULTIPOINT'         => Proxy\MultiPointProxy::class,
+//            'MULTIPOLYGON'       => Proxy\MultiPolygonProxy::class,
+//            'MULTISURFACE'       => Proxy\MultiSurfaceProxy::class,
+//            'POINT'              => Proxy\PointProxy::class,
+//            'POLYGON'            => Proxy\PolygonProxy::class,
+//            'POLYHEDRALSURFACE'  => Proxy\PolyhedralSurfaceProxy::class,
+//            'SURFACE'            => Proxy\SurfaceProxy::class,
+//            'TIN'                => Proxy\TinProxy::class,
+//            'TRIANGLE'           => Proxy\TriangleProxy::class
+//        ];
+//
+//        $geometryType = strtoupper($geometryType);
+//        $geometryType = preg_replace('/^ST_/', '', $geometryType);
+//        assert($geometryType !== null);
+//        $geometryType = preg_replace('/ .*/', '', $geometryType);
+//        assert($geometryType !== null);
+//
+//        if (! isset($proxyClasses[$geometryType])) {
+//            throw new GeometryEngineException('Unknown geometry type: ' . $geometryType);
+//        }
+//
+//        return $proxyClasses[$geometryType];
+//    }
+}

src/Engine/MariadbEngine.php

@@ -0,0 +1,180 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine;
+
+use Brick\Geo\Curve;
+use Brick\Geo\Engine\Database\DatabaseDriver;
+use Brick\Geo\Engine\Database\Query\BinaryValue;
+use Brick\Geo\Engine\Database\Query\ScalarValue;
+use Brick\Geo\Engine\Database\Result\Row;
+use Brick\Geo\Exception\GeometryEngineException;
+use Brick\Geo\Geometry;
+use Brick\Geo\Io\WkbReader;
+use Brick\Geo\Io\WkbWriter;
+use Brick\Geo\Point;
+use Override;
+
+/**
+ * Database engine based on MySQL.
+ */
+final readonly class MysqlEngine extends DatabaseEngine
+{
+    private WkbReader $wkbReader;
+    private WkbWriter $wkbWriter;
+
+    public function __construct(
+        // TODO private
+        public DatabaseDriver $driver,
+        // TODO
+        private bool $useProxy = true,
+    ) {
+        $this->wkbReader = new WkbReader();
+        $this->wkbWriter = new WkbWriter();
+    }
+
+    /**
+     * Builds and executes a SQL query for a GIS function.
+     *
+     * @param string                $function        The SQL GIS function to execute.
+     * @param list<Geometry|scalar> $parameters      The Geometry objects or scalar values to pass as parameters.
+     * @param bool                  $returnsGeometry Whether the GIS function returns a Geometry.
+     *
+     * @throws GeometryEngineException
+     */
+    private function query(string $function, array $parameters, bool $returnsGeometry) : Row
+    {
+        $query = ['SELECT '];
+
+        if ($returnsGeometry) {
+            $query[] = 'ST_AsWKB(g), ST_SRID(g) FROM (SELECT ';
+        }
+
+        $query[] = $function . '(';
+
+        foreach ($parameters as $key => $parameter) {
+            if ($key !== 0) {
+                $query[] = ',';
+            }
+
+            if ($parameter instanceof Geometry) {
+                if ($parameter instanceof Point && $parameter->isEmpty()) {
+                    // WKB does not support empty points, and MySQL does not support them either.
+                    throw new GeometryEngineException('MySQL does not support empty points');
+                }
+                $query[] = 'ST_GeomFromWKB(';
+                $query[] = new BinaryValue($this->wkbWriter->write($parameter));
+                $query[] = ',';
+                $query[] = new ScalarValue($parameter->srid());
+                $query[] = ')';
+            } else {
+                $query[] = new ScalarValue($parameter);
+            }
+        }
+
+        $query[] = ')';
+
+        if ($returnsGeometry) {
+            $query[] = ' AS g) AS q';
+        }
+
+        return $this->driver->executeQuery(...$query);
+    }
+
+    /**
+     * Queries a GIS function returning a boolean value.
+     *
+     * @param string          $function      The SQL GIS function to execute.
+     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
+     *
+     * @throws GeometryEngineException
+     */
+    #[Override]
+    protected function queryBool(string $function, Geometry|string|float|int|bool ...$parameters) : bool
+    {
+        return $this->query($function, $parameters, false)->get(0)->asBool();
+    }
+
+    /**
+     * Queries a GIS function returning a floating point value.
+     *
+     * @param string          $function      The SQL GIS function to execute.
+     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
+     *
+     * @throws GeometryEngineException
+     */
+    #[Override]
+    protected function queryFloat(string $function, Geometry|string|float|int|bool ...$parameters) : float
+    {
+        return $this->query($function, $parameters, false)->get(0)->asFloat();
+    }
+
+    /**
+     * Queries a GIS function returning a Geometry object.
+     *
+     * @param string             $function   The SQL GIS function to execute.
+     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
+     *
+     * @throws GeometryEngineException
+     */
+    #[Override]
+    protected function queryGeometry(string $function, Geometry|string|float|int|bool ...$parameters) : Geometry
+    {
+        $row = $this->query($function, $parameters, true);
+
+        $wkb = $row->get(0)->asBinary();
+        $srid = $row->get(1)->asInt();
+
+        return $this->wkbReader->read($wkb, $srid);
+    }
+
+//    /**
+//     * @return class-string<Proxy\ProxyInterface&Geometry>
+//     *
+//     * @throws GeometryEngineException
+//     */
+//    private function getProxyClassName(string $geometryType) : string
+//    {
+//        $proxyClasses = [
+//            'CIRCULARSTRING'     => Proxy\CircularStringProxy::class,
+//            'COMPOUNDCURVE'      => Proxy\CompoundCurveProxy::class,
+//            'CURVE'              => Proxy\CurveProxy::class,
+//            'CURVEPOLYGON'       => Proxy\CurvePolygonProxy::class,
+//            'GEOMCOLLECTION'     => Proxy\GeometryCollectionProxy::class, /* MySQL 8 - https://github.com/brick/geo/pull/33 */
+//            'GEOMETRY'           => Proxy\GeometryProxy::class,
+//            'GEOMETRYCOLLECTION' => Proxy\GeometryCollectionProxy::class,
+//            'LINESTRING'         => Proxy\LineStringProxy::class,
+//            'MULTICURVE'         => Proxy\MultiCurveProxy::class,
+//            'MULTILINESTRING'    => Proxy\MultiLineStringProxy::class,
+//            'MULTIPOINT'         => Proxy\MultiPointProxy::class,
+//            'MULTIPOLYGON'       => Proxy\MultiPolygonProxy::class,
+//            'MULTISURFACE'       => Proxy\MultiSurfaceProxy::class,
+//            'POINT'              => Proxy\PointProxy::class,
+//            'POLYGON'            => Proxy\PolygonProxy::class,
+//            'POLYHEDRALSURFACE'  => Proxy\PolyhedralSurfaceProxy::class,
+//            'SURFACE'            => Proxy\SurfaceProxy::class,
+//            'TIN'                => Proxy\TinProxy::class,
+//            'TRIANGLE'           => Proxy\TriangleProxy::class
+//        ];
+//
+//        $geometryType = strtoupper($geometryType);
+//        $geometryType = preg_replace('/^ST_/', '', $geometryType);
+//        assert($geometryType !== null);
+//        $geometryType = preg_replace('/ .*/', '', $geometryType);
+//        assert($geometryType !== null);
+//
+//        if (! isset($proxyClasses[$geometryType])) {
+//            throw new GeometryEngineException('Unknown geometry type: ' . $geometryType);
+//        }
+//
+//        return $proxyClasses[$geometryType];
+//    }
+
+    #[Override]
+    public function isRing(Curve $curve) : bool
+    {
+        // MySQL does not support ST_IsRing(), but we have an easy fallback.
+        return $this->isClosed($curve) && $this->isSimple($curve);
+    }
+}

src/Engine/MysqlEngine.php

@@ -1,112 +1,88 @@
 <?php
-
-declare(strict_types=1);
-
-namespace Brick\Geo\Engine;
-
-use Brick\Geo\Exception\GeometryEngineException;
-use Brick\Geo\Geometry;
-use Override;
-use PDO;
-use PDOException;
-use PDOStatement;
-
-/**
- * Database engine based on a PDO driver.
- */
-final class PdoEngine extends DatabaseEngine
-{
-    /**
-     * The database connection.
-     */
-    private readonly PDO $pdo;
-
-    /**
-     * A cache of the prepared statements, indexed by query.
-     *
-     * @var array<string, PDOStatement>
-     */
-    private array $statements = [];
-
-    public function __construct(PDO $pdo, bool $useProxy = true)
-    {
-        parent::__construct($useProxy);
-
-        $this->pdo = $pdo;
-    }
-
-    public function getPDO() : PDO
-    {
-        return $this->pdo;
-    }
-
-    #[Override]
-    protected function executeQuery(string $query, array $parameters) : array
-    {
-        /** @var int $errMode */
-        $errMode = $this->pdo->getAttribute(PDO::ATTR_ERRMODE);
-        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
-
-        try {
-            if (! isset($this->statements[$query])) {
-                $this->statements[$query] = $this->pdo->prepare($query);
-            }
-
-            $statement = $this->statements[$query];
-
-            $index = 1;
-
-            foreach ($parameters as $parameter) {
-                if ($parameter instanceof GeometryParameter) {
-                    $statement->bindValue($index++, $parameter->data, $parameter->isBinary ? PDO::PARAM_LOB : PDO::PARAM_STR);
-                    $statement->bindValue($index++, $parameter->srid, PDO::PARAM_INT);
-                } else {
-                    $type = match (true) {
-                        is_int($parameter) => PDO::PARAM_INT,
-                        is_bool($parameter) => PDO::PARAM_BOOL,
-                        default => PDO::PARAM_STR,
-                    };
-
-                    $statement->bindValue($index++, $parameter, $type);
-                }
-            }
-
-            $statement->execute();
-
-            /** @var list<mixed>|false $result */
-            $result = $statement->fetch(PDO::FETCH_NUM);
-        } catch (PDOException $e) {
-            throw GeometryEngineException::wrap($e);
-        } finally {
-            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, $errMode);
-        }
-
-        assert($result !== false);
-
-        return $result;
-    }
-
-    #[Override]
-    protected function getGeomFromWkbSyntax(): string
-    {
-        if ($this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME) === 'mysql') {
-            return 'ST_GeomFromWKB(BINARY ?, ?)';
-        }
-
-        return parent::getGeomFromWkbSyntax();
-    }
-
-    #[Override]
-    protected function getParameterPlaceholder(string|float|int|bool $parameter): string
-    {
-        if ($this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME) === 'pgsql') {
-            if (is_int($parameter)) {
-                // https://stackoverflow.com/q/66625661/759866
-                // https://externals.io/message/113521
-                return 'CAST (? AS INTEGER)';
-            }
-        }
-
-        return parent::getParameterPlaceholder($parameter);
-    }
-}
+//
+//declare(strict_types=1);
+//
+//namespace Brick\Geo\Engine;
+//
+//use Brick\Geo\Exception\GeometryEngineException;
+//use Brick\Geo\Geometry;
+//use Override;
+//use PDO;
+//use PDOException;
+//use PDOStatement;
+//
+///**
+// * Database engine based on a PDO driver.
+// */
+//final class PdoEngine extends DatabaseEngine
+//{
+//    /**
+//     * The database connection.
+//     */
+//    private readonly PDO $pdo;
+//
+//    /**
+//     * A cache of the prepared statements, indexed by query.
+//     *
+//     * @var array<string, PDOStatement>
+//     */
+//    private array $statements = [];
+//
+//    public function __construct(PDO $pdo, bool $useProxy = true)
+//    {
+//        parent::__construct($useProxy);
+//
+//        $this->pdo = $pdo;
+//    }
+//
+//    public function getPDO() : PDO
+//    {
+//        return $this->pdo;
+//    }
+//
+//    #[Override]
+//    protected function executeQuery(string $query, array $parameters) : array
+//    {
+//        /** @var int $errMode */
+//        $errMode = $this->pdo->getAttribute(PDO::ATTR_ERRMODE);
+//        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+//
+//        try {
+//            if (! isset($this->statements[$query])) {
+//                $this->statements[$query] = $this->pdo->prepare($query);
+//            }
+//
+//            $statement = $this->statements[$query];
+//
+//            $index = 1;
+//
+//            foreach ($parameters as $parameter) {
+//                if ($parameter instanceof GeometryParameter) {
+//                    $statement->bindValue($index++, $parameter->data, $parameter->isBinary ? PDO::PARAM_LOB : PDO::PARAM_STR);
+//                    $statement->bindValue($index++, $parameter->srid, PDO::PARAM_INT);
+//                } else {
+//                    $type = match (true) {
+//                        is_int($parameter) => PDO::PARAM_INT,
+//                        is_bool($parameter) => PDO::PARAM_BOOL,
+//                        default => PDO::PARAM_STR,
+//                    };
+//
+//                    $statement->bindValue($index++, $parameter, $type);
+//                }
+//            }
+//
+//            $statement->execute();
+//
+//            /** @var list<mixed>|false $result */
+//            $result = $statement->fetch(PDO::FETCH_NUM);
+//        } catch (PDOException $e) {
+//            throw GeometryEngineException::wrap($e);
+//        } finally {
+//            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, $errMode);
+//        }
+//
+//        assert($result !== false);
+//
+//        return $result;
+//    }
+//}

src/Engine/PdoEngine.php

@@ -0,0 +1,143 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Geo\Engine;
+
+use Brick\Geo\Engine\Database\DatabaseDriver;
+use Brick\Geo\Engine\Database\Query\BinaryValue;
+use Brick\Geo\Engine\Database\Query\ScalarValue;
+use Brick\Geo\Engine\Database\Result\Row;
+use Brick\Geo\Engine\Internal\TypeChecker;
+use Brick\Geo\Exception\GeometryEngineException;
+use Brick\Geo\Geometry;
+use Brick\Geo\Io\WkbReader;
+use Brick\Geo\Io\WkbWriter;
+use Brick\Geo\LineString;
+use Brick\Geo\Point;
+use Override;
+
+/**
+ * Database engine based on a SQLite3 driver.
+ *
+ * The spatialite extension must be loaded in this driver.
+ */
+final readonly class SpatialiteEngine extends DatabaseEngine
+{
+    private WkbReader $wkbReader;
+    private WkbWriter $wkbWriter;
+
+    public function __construct(
+        // TODO private
+        public DatabaseDriver $driver,
+        // TODO
+        private bool $useProxy = true,
+    ) {
+        $this->wkbReader = new WkbReader();
+        $this->wkbWriter = new WkbWriter();
+    }
+
+    /**
+     * Builds and executes a SQL query for a GIS function.
+     *
+     * @param string                $function        The SQL GIS function to execute.
+     * @param list<Geometry|scalar> $parameters      The Geometry objects or scalar values to pass as parameters.
+     * @param bool                  $returnsGeometry Whether the GIS function returns a Geometry.
+     *
+     * @throws GeometryEngineException
+     */
+    private function query(string $function, array $parameters, bool $returnsGeometry) : Row
+    {
+        $query = ['SELECT '];
+
+        if ($returnsGeometry) {
+            $query[] = 'ST_AsBinary(g), ST_SRID(g) FROM (SELECT ';
+        }
+
+        $query[] = $function . '(';
+
+        foreach ($parameters as $key => $parameter) {
+            if ($key !== 0) {
+                $query[] = ',';
+            }
+
+            if ($parameter instanceof Geometry) {
+                if ($parameter instanceof Point && $parameter->isEmpty()) {
+                    // WKB does not support empty points, and SpatiaLite does not support them either.
+                    throw new GeometryEngineException('MySQL does not support empty points');
+                }
+                $query[] = 'ST_GeomFromWKB(';
+                $query[] = new BinaryValue($this->wkbWriter->write($parameter));
+                $query[] = ',';
+                $query[] = new ScalarValue($parameter->srid());
+                $query[] = ')';
+            } else {
+                $query[] = new ScalarValue($parameter);
+            }
+        }
+
+        $query[] = ')';
+
+        if ($returnsGeometry) {
+            $query[] = ' AS g) AS q';
+        }
+
+        return $this->driver->executeQuery(...$query);
+    }
+
+    /**
+     * Queries a GIS function returning a boolean value.
+     *
+     * @param string          $function      The SQL GIS function to execute.
+     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
+     *
+     * @throws GeometryEngineException
+     */
+    #[Override]
+    protected function queryBool(string $function, Geometry|string|float|int|bool ...$parameters) : bool
+    {
+        return $this->query($function, $parameters, false)->get(0)->asBool();
+    }
+
+    /**
+     * Queries a GIS function returning a floating point value.
+     *
+     * @param string          $function      The SQL GIS function to execute.
+     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
+     *
+     * @throws GeometryEngineException
+     */
+    #[Override]
+    protected function queryFloat(string $function, Geometry|string|float|int|bool ...$parameters) : float
+    {
+        return $this->query($function, $parameters, false)->get(0)->asFloat();
+    }
+
+    /**
+     * Queries a GIS function returning a Geometry object.
+     *
+     * @param string             $function   The SQL GIS function to execute.
+     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
+     *
+     * @throws GeometryEngineException
+     */
+    #[Override]
+    protected function queryGeometry(string $function, Geometry|string|float|int|bool ...$parameters) : Geometry
+    {
+        $row = $this->query($function, $parameters, true);
+
+        $wkb = $row->get(0)->asBinary();
+        $srid = $row->get(1)->asInt();
+
+        return $this->wkbReader->read($wkb, $srid);
+    }
+
+    #[Override]
+    public function lineInterpolatePoint(LineString $lineString, float $fraction) : Point
+    {
+        $result = $this->queryGeometry('ST_Line_Interpolate_Point', $lineString, $fraction);
+        TypeChecker::check($result, Point::class);
+
+        return $result;
+    }
+}

src/Engine/PostgisEngine.php

@@ -30,6 +30,15 @@ public static function operationYieldedNoResult() : GeometryEngineException
         return new self('This operation yielded no result on the target database.');
     }
 
+    public static function unexpectedDatabaseReturnType(string $expectedType, mixed $actualValue) : GeometryEngineException
+    {
+        return new self(sprintf(
+            'The database returned an unexpected type: expected %s, got %s.',
+            $expectedType,
+            get_debug_type($actualValue),
+        ));
+    }
+
     /**
      * @param class-string<Geometry> $expectedClassName
      * @param class-string<Geometry> $actualClassName

src/Engine/SpatialiteEngine.php

@@ -11,8 +11,11 @@
 use Brick\Geo\Engine\GeometryEngine;
 use Brick\Geo\Engine\GeosEngine;
 use Brick\Geo\Engine\GeosOpEngine;
+use Brick\Geo\Engine\MariadbEngine;
+use Brick\Geo\Engine\MysqlEngine;
 use Brick\Geo\Engine\PdoEngine;
-use Brick\Geo\Engine\Sqlite3Engine;
+use Brick\Geo\Engine\PostgisEngine;
+use Brick\Geo\Engine\SpatialiteEngine;
 use Brick\Geo\Exception\GeometryEngineException;
 use Brick\Geo\Geometry;
 use Brick\Geo\GeometryCollection;
@@ -1416,6 +1419,7 @@ private function failsOnMysql(?string $operatorAndVersion = null) : void
     {
         if ($this->isMysql($operatorAndVersion)) {
             $this->expectException(GeometryEngineException::class);
+//            $this->expectExceptionMessage('is currently not implemented');
         }
     }
 
@@ -1449,29 +1453,69 @@ private function failsOnSpatialite(?string $operatorAndVersion = null) : void
 
     private function isMysql(?string $operatorAndVersion = null) : bool
     {
-        return $this->isMysqlOrMariadb(false, $operatorAndVersion);
+        $engine = $this->getGeometryEngine();
+
+        if ($engine instanceof MysqlEngine) {
+            // TODO remove...
+            $version = $engine->driver->executeQuery('SELECT VERSION()')->get(0)->asString();
+
+            $pos = strpos($version, '-MariaDB');
+            $isMariadb = ($pos !== false);
+
+            if ($isMariadb) {
+                return false;
+            }
+            // TODO up to here
+
+            if ($operatorAndVersion === null) {
+                return true;
+            }
+
+            $version = $engine->driver->executeQuery('SELECT VERSION()')->get(0)->asString();
+
+            return $this->isVersion($version, $operatorAndVersion);
+        }
+
+        return false;
     }
 
     private function isMariadb(?string $operatorAndVersion = null) : bool
     {
-        return $this->isMysqlOrMariadb(true, $operatorAndVersion);
+        $engine = $this->getGeometryEngine();
+
+        if ($engine instanceof MariadbEngine) {
+            if ($operatorAndVersion === null) {
+                return true;
+            }
+
+            $version = $engine->driver->executeQuery('SELECT VERSION()')->get(0)->asString();
+            $pos = strpos($version, '-MariaDB');
+
+            if ($pos !== false) {
+                $version = substr($version, 0, $pos);
+            }
+
+            return $this->isVersion($version, $operatorAndVersion);
+        }
+
+        return false;
     }
 
     private function isPostgis() : bool
     {
-        return $this->isPdoDriver('pgsql');
+        return $this->getGeometryEngine() instanceof PostgisEngine;
     }
 
     private function isSpatialite(?string $operatorAndVersion = null) : bool
     {
         $engine = $this->getGeometryEngine();
 
-        if ($engine instanceof Sqlite3Engine) {
+        if ($engine instanceof SpatialiteEngine) {
             if ($operatorAndVersion === null) {
                 return true;
             }
 
-            $version = $engine->getSQLite3()->querySingle('SELECT spatialite_version()');
+            $version = $engine->driver->executeQuery('SELECT spatialite_version()')->get(0)->asString();
 
             return $this->isVersion($version, $operatorAndVersion);
         }
@@ -1580,6 +1624,7 @@ private function skipIfUnsupportedGeometry(Geometry $geometry) : void
             $this->failsOnMariadb();
 
             if ($this->isSpatialite()) {
+                // TODO check if throws exceptions
                 self::markTestSkipped('SpatiaLite does not correctly handle empty geometries.');
             }
         }
@@ -1670,42 +1715,6 @@ private function isPdoDriver(string $name) : bool
             }
         }
 
-        return false;
-    }
-    /**
-     * @param bool        $testMariadb        False to check for MYSQL, true to check for MariaDB.
-     * @param string|null $operatorAndVersion An optional comparison operator and version number to test against.
-     */
-    private function isMysqlOrMariadb(bool $testMariadb, ?string $operatorAndVersion = null) : bool
-    {
-        $engine = $this->getGeometryEngine();
-
-        if ($engine instanceof PdoEngine) {
-            $pdo = $engine->getPDO();
-
-            if ($pdo->getAttribute(\PDO::ATTR_DRIVER_NAME) === 'mysql') {
-                $statement = $pdo->query('SELECT VERSION()');
-                $version = $statement->fetchColumn();
-
-                $pos = strpos($version, '-MariaDB');
-                $isMariadb = ($pos !== false);
-
-                if ($isMariadb) {
-                    $version = substr($version, 0, $pos);
-                }
-
-                if ($testMariadb !== $isMariadb) {
-                    return false;
-                }
-
-                if ($operatorAndVersion === null) {
-                    return true;
-                }
-
-                return $this->isVersion($version, $operatorAndVersion);
-            }
-        }
-
         return false;
     }
 }