VERSION 0.2 doctrine ORM et entités

16 files changed, 874 insertions, 0 deletions

diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Connection.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Connection.php
new file mode 100644
index 0000000..cc00fb6
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Connection.php
@@ -0,0 +1,112 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli;
+
+use Doctrine\DBAL\Driver\Connection as ConnectionInterface;
+use Doctrine\DBAL\Driver\Exception;
+use Doctrine\DBAL\Driver\Mysqli\Exception\ConnectionError;
+use mysqli;
+use mysqli_sql_exception;
+
+final class Connection implements ConnectionInterface
+{
+    /**
+     * Name of the option to set connection flags
+     */
+    public const OPTION_FLAGS = 'flags';
+
+    /** @internal The connection can be only instantiated by its driver. */
+    public function __construct(private readonly mysqli $connection)
+    {
+    }
+
+    public function getServerVersion(): string
+    {
+        return $this->connection->get_server_info();
+    }
+
+    public function prepare(string $sql): Statement
+    {
+        try {
+            $stmt = $this->connection->prepare($sql);
+        } catch (mysqli_sql_exception $e) {
+            throw ConnectionError::upcast($e);
+        }
+
+        if ($stmt === false) {
+            throw ConnectionError::new($this->connection);
+        }
+
+        return new Statement($stmt);
+    }
+
+    public function query(string $sql): Result
+    {
+        return $this->prepare($sql)->execute();
+    }
+
+    public function quote(string $value): string
+    {
+        return "'" . $this->connection->escape_string($value) . "'";
+    }
+
+    public function exec(string $sql): int|string
+    {
+        try {
+            $result = $this->connection->query($sql);
+        } catch (mysqli_sql_exception $e) {
+            throw ConnectionError::upcast($e);
+        }
+
+        if ($result === false) {
+            throw ConnectionError::new($this->connection);
+        }
+
+        return $this->connection->affected_rows;
+    }
+
+    public function lastInsertId(): int|string
+    {
+        $lastInsertId = $this->connection->insert_id;
+
+        if ($lastInsertId === 0) {
+            throw Exception\NoIdentityValue::new();
+        }
+
+        return $this->connection->insert_id;
+    }
+
+    public function beginTransaction(): void
+    {
+        $this->connection->begin_transaction();
+    }
+
+    public function commit(): void
+    {
+        try {
+            if (! $this->connection->commit()) {
+                throw ConnectionError::new($this->connection);
+            }
+        } catch (mysqli_sql_exception $e) {
+            throw ConnectionError::upcast($e);
+        }
+    }
+
+    public function rollBack(): void
+    {
+        try {
+            if (! $this->connection->rollback()) {
+                throw ConnectionError::new($this->connection);
+            }
+        } catch (mysqli_sql_exception $e) {
+            throw ConnectionError::upcast($e);
+        }
+    }
+
+    public function getNativeConnection(): mysqli
+    {
+        return $this->connection;
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Driver.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Driver.php
new file mode 100644
index 0000000..9855e56
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Driver.php
@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli;
+
+use Doctrine\DBAL\Driver\AbstractMySQLDriver;
+use Doctrine\DBAL\Driver\Mysqli\Exception\ConnectionFailed;
+use Doctrine\DBAL\Driver\Mysqli\Exception\HostRequired;
+use Doctrine\DBAL\Driver\Mysqli\Initializer\Charset;
+use Doctrine\DBAL\Driver\Mysqli\Initializer\Options;
+use Doctrine\DBAL\Driver\Mysqli\Initializer\Secure;
+use Generator;
+use mysqli;
+use mysqli_sql_exception;
+use SensitiveParameter;
+
+final class Driver extends AbstractMySQLDriver
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function connect(
+        #[SensitiveParameter]
+        array $params,
+    ): Connection {
+        if (! empty($params['persistent'])) {
+            if (! isset($params['host'])) {
+                throw HostRequired::forPersistentConnection();
+            }
+
+            $host = 'p:' . $params['host'];
+        } else {
+            $host = $params['host'] ?? '';
+        }
+
+        $connection = new mysqli();
+
+        foreach ($this->compilePreInitializers($params) as $initializer) {
+            $initializer->initialize($connection);
+        }
+
+        try {
+            $success = @$connection->real_connect(
+                $host,
+                $params['user'] ?? '',
+                $params['password'] ?? '',
+                $params['dbname'] ?? '',
+                $params['port'] ?? 0,
+                $params['unix_socket'] ?? '',
+                $params['driverOptions'][Connection::OPTION_FLAGS] ?? 0,
+            );
+        } catch (mysqli_sql_exception $e) {
+            throw ConnectionFailed::upcast($e);
+        }
+
+        if (! $success) {
+            throw ConnectionFailed::new($connection);
+        }
+
+        foreach ($this->compilePostInitializers($params) as $initializer) {
+            $initializer->initialize($connection);
+        }
+
+        return new Connection($connection);
+    }
+
+    /**
+     * @param array<string, mixed> $params
+     *
+     * @return Generator<int, Initializer>
+     */
+    private function compilePreInitializers(
+        #[SensitiveParameter]
+        array $params,
+    ): Generator {
+        unset($params['driverOptions'][Connection::OPTION_FLAGS]);
+
+        if (isset($params['driverOptions']) && $params['driverOptions'] !== []) {
+            yield new Options($params['driverOptions']);
+        }
+
+        if (
+            ! isset($params['ssl_key']) &&
+            ! isset($params['ssl_cert']) &&
+            ! isset($params['ssl_ca']) &&
+            ! isset($params['ssl_capath']) &&
+            ! isset($params['ssl_cipher'])
+        ) {
+            return;
+        }
+
+        yield new Secure(
+            $params['ssl_key']    ?? '',
+            $params['ssl_cert']   ?? '',
+            $params['ssl_ca']     ?? '',
+            $params['ssl_capath'] ?? '',
+            $params['ssl_cipher'] ?? '',
+        );
+    }
+
+    /**
+     * @param array<string, mixed> $params
+     *
+     * @return Generator<int, Initializer>
+     */
+    private function compilePostInitializers(
+        #[SensitiveParameter]
+        array $params,
+    ): Generator {
+        if (! isset($params['charset'])) {
+            return;
+        }
+
+        yield new Charset($params['charset']);
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/ConnectionError.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/ConnectionError.php
new file mode 100644
index 0000000..d2477fd
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/ConnectionError.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Exception;
+
+use Doctrine\DBAL\Driver\AbstractException;
+use mysqli;
+use mysqli_sql_exception;
+use ReflectionProperty;
+
+/**
+ * @internal
+ *
+ * @psalm-immutable
+ */
+final class ConnectionError extends AbstractException
+{
+    public static function new(mysqli $connection): self
+    {
+        return new self($connection->error, $connection->sqlstate, $connection->errno);
+    }
+
+    public static function upcast(mysqli_sql_exception $exception): self
+    {
+        $p = new ReflectionProperty(mysqli_sql_exception::class, 'sqlstate');
+
+        return new self($exception->getMessage(), $p->getValue($exception), $exception->getCode(), $exception);
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/ConnectionFailed.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/ConnectionFailed.php
new file mode 100644
index 0000000..cb3bc64
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/ConnectionFailed.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Exception;
+
+use Doctrine\DBAL\Driver\AbstractException;
+use mysqli;
+use mysqli_sql_exception;
+use ReflectionProperty;
+
+use function assert;
+
+/**
+ * @internal
+ *
+ * @psalm-immutable
+ */
+final class ConnectionFailed extends AbstractException
+{
+    public static function new(mysqli $connection): self
+    {
+        $error = $connection->connect_error;
+        assert($error !== null);
+
+        return new self($error, 'HY000', $connection->connect_errno);
+    }
+
+    public static function upcast(mysqli_sql_exception $exception): self
+    {
+        $p = new ReflectionProperty(mysqli_sql_exception::class, 'sqlstate');
+
+        return new self($exception->getMessage(), $p->getValue($exception), $exception->getCode(), $exception);
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/FailedReadingStreamOffset.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/FailedReadingStreamOffset.php
new file mode 100644
index 0000000..6f26dbe
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/FailedReadingStreamOffset.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Exception;
+
+use Doctrine\DBAL\Driver\AbstractException;
+
+use function sprintf;
+
+/**
+ * @internal
+ *
+ * @psalm-immutable
+ */
+final class FailedReadingStreamOffset extends AbstractException
+{
+    public static function new(int $parameter): self
+    {
+        return new self(sprintf('Failed reading the stream resource for parameter #%d.', $parameter));
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/HostRequired.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/HostRequired.php
new file mode 100644
index 0000000..d3359fc
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/HostRequired.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Exception;
+
+use Doctrine\DBAL\Driver\AbstractException;
+
+/**
+ * @internal
+ *
+ * @psalm-immutable
+ */
+final class HostRequired extends AbstractException
+{
+    public static function forPersistentConnection(): self
+    {
+        return new self('The "host" parameter is required for a persistent connection');
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/InvalidCharset.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/InvalidCharset.php
new file mode 100644
index 0000000..778ea64
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/InvalidCharset.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Exception;
+
+use Doctrine\DBAL\Driver\AbstractException;
+use mysqli;
+use mysqli_sql_exception;
+use ReflectionProperty;
+
+use function sprintf;
+
+/**
+ * @internal
+ *
+ * @psalm-immutable
+ */
+final class InvalidCharset extends AbstractException
+{
+    public static function fromCharset(mysqli $connection, string $charset): self
+    {
+        return new self(
+            sprintf('Failed to set charset "%s": %s', $charset, $connection->error),
+            $connection->sqlstate,
+            $connection->errno,
+        );
+    }
+
+    public static function upcast(mysqli_sql_exception $exception, string $charset): self
+    {
+        $p = new ReflectionProperty(mysqli_sql_exception::class, 'sqlstate');
+
+        return new self(
+            sprintf('Failed to set charset "%s": %s', $charset, $exception->getMessage()),
+            $p->getValue($exception),
+            $exception->getCode(),
+            $exception,
+        );
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/InvalidOption.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/InvalidOption.php
new file mode 100644
index 0000000..654bb87
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/InvalidOption.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Exception;
+
+use Doctrine\DBAL\Driver\AbstractException;
+
+use function sprintf;
+
+/**
+ * @internal
+ *
+ * @psalm-immutable
+ */
+final class InvalidOption extends AbstractException
+{
+    public static function fromOption(int $option, mixed $value): self
+    {
+        return new self(
+            sprintf('Failed to set option %d with value "%s"', $option, $value),
+        );
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/NonStreamResourceUsedAsLargeObject.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/NonStreamResourceUsedAsLargeObject.php
new file mode 100644
index 0000000..566d636
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/NonStreamResourceUsedAsLargeObject.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Exception;
+
+use Doctrine\DBAL\Driver\AbstractException;
+
+use function sprintf;
+
+/**
+ * @internal
+ *
+ * @psalm-immutable
+ */
+final class NonStreamResourceUsedAsLargeObject extends AbstractException
+{
+    public static function new(int $parameter): self
+    {
+        return new self(
+            sprintf('The resource passed as a LARGE_OBJECT parameter #%d must be of type "stream"', $parameter),
+        );
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/StatementError.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/StatementError.php
new file mode 100644
index 0000000..991384c
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Exception/StatementError.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Exception;
+
+use Doctrine\DBAL\Driver\AbstractException;
+use mysqli_sql_exception;
+use mysqli_stmt;
+use ReflectionProperty;
+
+/**
+ * @internal
+ *
+ * @psalm-immutable
+ */
+final class StatementError extends AbstractException
+{
+    public static function new(mysqli_stmt $statement): self
+    {
+        return new self($statement->error, $statement->sqlstate, $statement->errno);
+    }
+
+    public static function upcast(mysqli_sql_exception $exception): self
+    {
+        $p = new ReflectionProperty(mysqli_sql_exception::class, 'sqlstate');
+
+        return new self($exception->getMessage(), $p->getValue($exception), $exception->getCode(), $exception);
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer.php
new file mode 100644
index 0000000..efab67e
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli;
+
+use Doctrine\DBAL\Driver\Exception;
+use mysqli;
+
+interface Initializer
+{
+    /** @throws Exception */
+    public function initialize(mysqli $connection): void;
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer/Charset.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer/Charset.php
new file mode 100644
index 0000000..d02c768
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer/Charset.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Initializer;
+
+use Doctrine\DBAL\Driver\Mysqli\Exception\InvalidCharset;
+use Doctrine\DBAL\Driver\Mysqli\Initializer;
+use mysqli;
+use mysqli_sql_exception;
+
+final class Charset implements Initializer
+{
+    public function __construct(private readonly string $charset)
+    {
+    }
+
+    public function initialize(mysqli $connection): void
+    {
+        try {
+            $success = $connection->set_charset($this->charset);
+        } catch (mysqli_sql_exception $e) {
+            throw InvalidCharset::upcast($e, $this->charset);
+        }
+
+        if ($success) {
+            return;
+        }
+
+        throw InvalidCharset::fromCharset($connection, $this->charset);
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer/Options.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer/Options.php
new file mode 100644
index 0000000..3223951
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer/Options.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Initializer;
+
+use Doctrine\DBAL\Driver\Mysqli\Exception\InvalidOption;
+use Doctrine\DBAL\Driver\Mysqli\Initializer;
+use mysqli;
+
+use function mysqli_options;
+
+final class Options implements Initializer
+{
+    /** @param array<int,mixed> $options */
+    public function __construct(private readonly array $options)
+    {
+    }
+
+    public function initialize(mysqli $connection): void
+    {
+        foreach ($this->options as $option => $value) {
+            if (! mysqli_options($connection, $option, $value)) {
+                throw InvalidOption::fromOption($option, $value);
+            }
+        }
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer/Secure.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer/Secure.php
new file mode 100644
index 0000000..fa819b5
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Initializer/Secure.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli\Initializer;
+
+use Doctrine\DBAL\Driver\Mysqli\Initializer;
+use mysqli;
+use SensitiveParameter;
+
+final class Secure implements Initializer
+{
+    public function __construct(
+        #[SensitiveParameter]
+        private readonly string $key,
+        private readonly string $cert,
+        private readonly string $ca,
+        private readonly string $capath,
+        private readonly string $cipher,
+    ) {
+    }
+
+    public function initialize(mysqli $connection): void
+    {
+        $connection->ssl_set($this->key, $this->cert, $this->ca, $this->capath, $this->cipher);
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Result.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Result.php
new file mode 100644
index 0000000..8d3c47a
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Result.php
@@ -0,0 +1,164 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli;
+
+use Doctrine\DBAL\Driver\Exception;
+use Doctrine\DBAL\Driver\FetchUtils;
+use Doctrine\DBAL\Driver\Mysqli\Exception\StatementError;
+use Doctrine\DBAL\Driver\Result as ResultInterface;
+use mysqli_sql_exception;
+use mysqli_stmt;
+
+use function array_column;
+use function array_combine;
+use function array_fill;
+use function count;
+
+final class Result implements ResultInterface
+{
+    /**
+     * Whether the statement result has columns. The property should be used only after the result metadata
+     * has been fetched ({@see $metadataFetched}). Otherwise, the property value is undetermined.
+     */
+    private readonly bool $hasColumns;
+
+    /**
+     * Mapping of statement result column indexes to their names. The property should be used only
+     * if the statement result has columns ({@see $hasColumns}). Otherwise, the property value is undetermined.
+     *
+     * @var array<int,string>
+     */
+    private readonly array $columnNames;
+
+    /** @var mixed[] */
+    private array $boundValues = [];
+
+    /**
+     * @internal The result can be only instantiated by its driver connection or statement.
+     *
+     * @throws Exception
+     */
+    public function __construct(private readonly mysqli_stmt $statement)
+    {
+        $meta              = $statement->result_metadata();
+        $this->hasColumns  = $meta !== false;
+        $this->columnNames = $meta !== false ? array_column($meta->fetch_fields(), 'name') : [];
+
+        if ($meta === false) {
+            return;
+        }
+
+        $meta->free();
+
+        // Store result of every execution which has it. Otherwise it will be impossible
+        // to execute a new statement in case if the previous one has non-fetched rows
+        // @link http://dev.mysql.com/doc/refman/5.7/en/commands-out-of-sync.html
+        $this->statement->store_result();
+
+        // Bind row values _after_ storing the result. Otherwise, if mysqli is compiled with libmysql,
+        // it will have to allocate as much memory as it may be needed for the given column type
+        // (e.g. for a LONGBLOB column it's 4 gigabytes)
+        // @link https://bugs.php.net/bug.php?id=51386#1270673122
+        //
+        // Make sure that the values are bound after each execution. Otherwise, if free() has been
+        // previously called on the result, the values are unbound making the statement unusable.
+        //
+        // It's also important that row values are bound after _each_ call to store_result(). Otherwise,
+        // if mysqli is compiled with libmysql, subsequently fetched string values will get truncated
+        // to the length of the ones fetched during the previous execution.
+        $this->boundValues = array_fill(0, count($this->columnNames), null);
+
+        // The following is necessary as PHP cannot handle references to properties properly
+        $refs = &$this->boundValues;
+
+        if (! $this->statement->bind_result(...$refs)) {
+            throw StatementError::new($this->statement);
+        }
+    }
+
+    public function fetchNumeric(): array|false
+    {
+        try {
+            $ret = $this->statement->fetch();
+        } catch (mysqli_sql_exception $e) {
+            throw StatementError::upcast($e);
+        }
+
+        if ($ret === false) {
+            throw StatementError::new($this->statement);
+        }
+
+        if ($ret === null) {
+            return false;
+        }
+
+        $values = [];
+
+        foreach ($this->boundValues as $v) {
+            $values[] = $v;
+        }
+
+        return $values;
+    }
+
+    public function fetchAssociative(): array|false
+    {
+        $values = $this->fetchNumeric();
+
+        if ($values === false) {
+            return false;
+        }
+
+        return array_combine($this->columnNames, $values);
+    }
+
+    public function fetchOne(): mixed
+    {
+        return FetchUtils::fetchOne($this);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function fetchAllNumeric(): array
+    {
+        return FetchUtils::fetchAllNumeric($this);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function fetchAllAssociative(): array
+    {
+        return FetchUtils::fetchAllAssociative($this);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function fetchFirstColumn(): array
+    {
+        return FetchUtils::fetchFirstColumn($this);
+    }
+
+    public function rowCount(): int|string
+    {
+        if ($this->hasColumns) {
+            return $this->statement->num_rows;
+        }
+
+        return $this->statement->affected_rows;
+    }
+
+    public function columnCount(): int
+    {
+        return $this->statement->field_count;
+    }
+
+    public function free(): void
+    {
+        $this->statement->free_result();
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Driver/Mysqli/Statement.php b/vendor/doctrine/dbal/src/Driver/Mysqli/Statement.php
new file mode 100644
index 0000000..8436fad
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Driver/Mysqli/Statement.php
@@ -0,0 +1,154 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Driver\Mysqli;
+
+use Doctrine\DBAL\Driver\Exception;
+use Doctrine\DBAL\Driver\Mysqli\Exception\FailedReadingStreamOffset;
+use Doctrine\DBAL\Driver\Mysqli\Exception\NonStreamResourceUsedAsLargeObject;
+use Doctrine\DBAL\Driver\Mysqli\Exception\StatementError;
+use Doctrine\DBAL\Driver\Statement as StatementInterface;
+use Doctrine\DBAL\ParameterType;
+use mysqli_sql_exception;
+use mysqli_stmt;
+
+use function array_fill;
+use function assert;
+use function count;
+use function feof;
+use function fread;
+use function get_resource_type;
+use function is_int;
+use function is_resource;
+use function str_repeat;
+
+final class Statement implements StatementInterface
+{
+    private const PARAMETER_TYPE_STRING  = 's';
+    private const PARAMETER_TYPE_INTEGER = 'i';
+    private const PARAMETER_TYPE_BINARY  = 'b';
+
+    /** @var mixed[] */
+    private array $boundValues;
+
+    private string $types;
+
+    /**
+     * Contains ref values for bindValue().
+     *
+     * @var mixed[]
+     */
+    private array $values = [];
+
+    /** @internal The statement can be only instantiated by its driver connection. */
+    public function __construct(private readonly mysqli_stmt $stmt)
+    {
+        $paramCount        = $this->stmt->param_count;
+        $this->types       = str_repeat(self::PARAMETER_TYPE_STRING, $paramCount);
+        $this->boundValues = array_fill(1, $paramCount, null);
+    }
+
+    public function bindValue(int|string $param, mixed $value, ParameterType $type): void
+    {
+        assert(is_int($param));
+
+        $this->types[$param - 1]   = $this->convertParameterType($type);
+        $this->values[$param]      = $value;
+        $this->boundValues[$param] =& $this->values[$param];
+    }
+
+    public function execute(): Result
+    {
+        if (count($this->boundValues) > 0) {
+            $this->bindParameters();
+        }
+
+        try {
+            if (! $this->stmt->execute()) {
+                throw StatementError::new($this->stmt);
+            }
+        } catch (mysqli_sql_exception $e) {
+            throw StatementError::upcast($e);
+        }
+
+        return new Result($this->stmt);
+    }
+
+    /**
+     * Binds parameters with known types previously bound to the statement
+     *
+     * @throws Exception
+     */
+    private function bindParameters(): void
+    {
+        $streams = $values = [];
+        $types   = $this->types;
+
+        foreach ($this->boundValues as $parameter => $value) {
+            assert(is_int($parameter));
+            if (! isset($types[$parameter - 1])) {
+                $types[$parameter - 1] = self::PARAMETER_TYPE_STRING;
+            }
+
+            if ($types[$parameter - 1] === self::PARAMETER_TYPE_BINARY) {
+                if (is_resource($value)) {
+                    if (get_resource_type($value) !== 'stream') {
+                        throw NonStreamResourceUsedAsLargeObject::new($parameter);
+                    }
+
+                    $streams[$parameter] = $value;
+                    $values[$parameter]  = null;
+                    continue;
+                }
+
+                $types[$parameter - 1] = self::PARAMETER_TYPE_STRING;
+            }
+
+            $values[$parameter] = $value;
+        }
+
+        if (! $this->stmt->bind_param($types, ...$values)) {
+            throw StatementError::new($this->stmt);
+        }
+
+        $this->sendLongData($streams);
+    }
+
+    /**
+     * Handle $this->_longData after regular query parameters have been bound
+     *
+     * @param array<int, resource> $streams
+     *
+     * @throws Exception
+     */
+    private function sendLongData(array $streams): void
+    {
+        foreach ($streams as $paramNr => $stream) {
+            while (! feof($stream)) {
+                $chunk = fread($stream, 8192);
+
+                if ($chunk === false) {
+                    throw FailedReadingStreamOffset::new($paramNr);
+                }
+
+                if (! $this->stmt->send_long_data($paramNr - 1, $chunk)) {
+                    throw StatementError::new($this->stmt);
+                }
+            }
+        }
+    }
+
+    private function convertParameterType(ParameterType $type): string
+    {
+        return match ($type) {
+            ParameterType::NULL,
+            ParameterType::STRING,
+            ParameterType::ASCII,
+            ParameterType::BINARY => self::PARAMETER_TYPE_STRING,
+            ParameterType::INTEGER,
+            ParameterType::BOOLEAN => self::PARAMETER_TYPE_INTEGER,
+            ParameterType::LARGE_OBJECT => self::PARAMETER_TYPE_BINARY,
+        };
+    }
+}