VERSION 0.2 doctrine ORM et entités

5 files changed, 396 insertions, 0 deletions

diff --git a/vendor/doctrine/dbal/src/Tools/Console/Command/RunSqlCommand.php b/vendor/doctrine/dbal/src/Tools/Console/Command/RunSqlCommand.php
new file mode 100644
index 0000000..8ec6f23
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Tools/Console/Command/RunSqlCommand.php
@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Tools\Console\Command;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Exception;
+use Doctrine\DBAL\Tools\Console\ConnectionProvider;
+use RuntimeException;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+use function array_keys;
+use function assert;
+use function is_bool;
+use function is_string;
+use function sprintf;
+use function stripos;
+
+/**
+ * Task for executing arbitrary SQL that can come from a file or directly from
+ * the command line.
+ */
+class RunSqlCommand extends Command
+{
+    public function __construct(private readonly ConnectionProvider $connectionProvider)
+    {
+        parent::__construct();
+    }
+
+    protected function configure(): void
+    {
+        $this
+        ->setName('dbal:run-sql')
+        ->setDescription('Executes arbitrary SQL directly from the command line.')
+        ->setDefinition([
+            new InputOption('connection', null, InputOption::VALUE_REQUIRED, 'The named database connection'),
+            new InputArgument('sql', InputArgument::REQUIRED, 'The SQL statement to execute.'),
+            new InputOption('depth', null, InputOption::VALUE_REQUIRED, 'Dumping depth of result set (deprecated).'),
+            new InputOption('force-fetch', null, InputOption::VALUE_NONE, 'Forces fetching the result.'),
+        ])
+        ->setHelp(<<<'EOT'
+The <info>%command.name%</info> command executes the given SQL query and
+outputs the results:
+
+<info>php %command.full_name% "SELECT * FROM users"</info>
+EOT);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws Exception
+     */
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $conn = $this->getConnection($input);
+        $io   = new SymfonyStyle($input, $output);
+
+        $sql = $input->getArgument('sql');
+
+        if ($sql === null) {
+            throw new RuntimeException('Argument "sql" is required in order to execute this command correctly.');
+        }
+
+        assert(is_string($sql));
+
+        if ($input->getOption('depth') !== null) {
+            $io->warning('Parameter "depth" is deprecated and has no effect anymore.');
+        }
+
+        $forceFetch = $input->getOption('force-fetch');
+        assert(is_bool($forceFetch));
+
+        if (stripos($sql, 'select') === 0 || $forceFetch) {
+            $this->runQuery($io, $conn, $sql);
+        } else {
+            $this->runStatement($io, $conn, $sql);
+        }
+
+        return 0;
+    }
+
+    private function getConnection(InputInterface $input): Connection
+    {
+        $connectionName = $input->getOption('connection');
+        assert(is_string($connectionName) || $connectionName === null);
+
+        if ($connectionName !== null) {
+            return $this->connectionProvider->getConnection($connectionName);
+        }
+
+        return $this->connectionProvider->getDefaultConnection();
+    }
+
+    /** @throws Exception */
+    private function runQuery(SymfonyStyle $io, Connection $conn, string $sql): void
+    {
+        $resultSet = $conn->fetchAllAssociative($sql);
+        if ($resultSet === []) {
+            $io->success('The query yielded an empty result set.');
+
+            return;
+        }
+
+        $io->table(array_keys($resultSet[0]), $resultSet);
+    }
+
+    /** @throws Exception */
+    private function runStatement(SymfonyStyle $io, Connection $conn, string $sql): void
+    {
+        $io->success(sprintf('%d rows affected.', $conn->executeStatement($sql)));
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Tools/Console/ConnectionNotFound.php b/vendor/doctrine/dbal/src/Tools/Console/ConnectionNotFound.php
new file mode 100644
index 0000000..049d658
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Tools/Console/ConnectionNotFound.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Tools\Console;
+
+use OutOfBoundsException;
+
+final class ConnectionNotFound extends OutOfBoundsException
+{
+}
diff --git a/vendor/doctrine/dbal/src/Tools/Console/ConnectionProvider.php b/vendor/doctrine/dbal/src/Tools/Console/ConnectionProvider.php
new file mode 100644
index 0000000..0ae28c5
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Tools/Console/ConnectionProvider.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Tools\Console;
+
+use Doctrine\DBAL\Connection;
+
+interface ConnectionProvider
+{
+    public function getDefaultConnection(): Connection;
+
+    /** @throws ConnectionNotFound in case a connection with the given name does not exist. */
+    public function getConnection(string $name): Connection;
+}
diff --git a/vendor/doctrine/dbal/src/Tools/Console/ConnectionProvider/SingleConnectionProvider.php b/vendor/doctrine/dbal/src/Tools/Console/ConnectionProvider/SingleConnectionProvider.php
new file mode 100644
index 0000000..12b40c0
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Tools/Console/ConnectionProvider/SingleConnectionProvider.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Tools\Console\ConnectionProvider;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Tools\Console\ConnectionNotFound;
+use Doctrine\DBAL\Tools\Console\ConnectionProvider;
+
+use function sprintf;
+
+class SingleConnectionProvider implements ConnectionProvider
+{
+    public function __construct(
+        private readonly Connection $connection,
+        private readonly string $defaultConnectionName = 'default',
+    ) {
+    }
+
+    public function getDefaultConnection(): Connection
+    {
+        return $this->connection;
+    }
+
+    public function getConnection(string $name): Connection
+    {
+        if ($name !== $this->defaultConnectionName) {
+            throw new ConnectionNotFound(sprintf('Connection with name "%s" does not exist.', $name));
+        }
+
+        return $this->connection;
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Tools/DsnParser.php b/vendor/doctrine/dbal/src/Tools/DsnParser.php
new file mode 100644
index 0000000..61edc6a
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Tools/DsnParser.php
@@ -0,0 +1,217 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Tools;
+
+use Doctrine\DBAL\Driver;
+use Doctrine\DBAL\DriverManager;
+use Doctrine\DBAL\Exception\MalformedDsnException;
+use SensitiveParameter;
+
+use function array_merge;
+use function assert;
+use function is_a;
+use function is_string;
+use function parse_str;
+use function parse_url;
+use function preg_replace;
+use function rawurldecode;
+use function str_replace;
+use function strpos;
+use function substr;
+
+/** @psalm-import-type Params from DriverManager */
+final class DsnParser
+{
+    /** @param array<string, string|class-string<Driver>> $schemeMapping An array used to map DSN schemes to DBAL drivers */
+    public function __construct(
+        private readonly array $schemeMapping = [],
+    ) {
+    }
+
+    /**
+     * @psalm-return Params
+     *
+     * @throws MalformedDsnException
+     */
+    public function parse(
+        #[SensitiveParameter]
+        string $dsn,
+    ): array {
+        // (pdo-)?sqlite3?:///... => (pdo-)?sqlite3?://localhost/... or else the URL will be invalid
+        $url = preg_replace('#^((?:pdo-)?sqlite3?):///#', '$1://localhost/', $dsn);
+        assert($url !== null);
+
+        $url = parse_url($url);
+
+        if ($url === false) {
+            throw MalformedDsnException::new();
+        }
+
+        foreach ($url as $param => $value) {
+            if (! is_string($value)) {
+                continue;
+            }
+
+            $url[$param] = rawurldecode($value);
+        }
+
+        $params = [];
+
+        if (isset($url['scheme'])) {
+            $params['driver'] = $this->parseDatabaseUrlScheme($url['scheme']);
+        }
+
+        if (isset($url['host'])) {
+            $params['host'] = $url['host'];
+        }
+
+        if (isset($url['port'])) {
+            $params['port'] = $url['port'];
+        }
+
+        if (isset($url['user'])) {
+            $params['user'] = $url['user'];
+        }
+
+        if (isset($url['pass'])) {
+            $params['password'] = $url['pass'];
+        }
+
+        if (isset($params['driver']) && is_a($params['driver'], Driver::class, true)) {
+            $params['driverClass'] = $params['driver'];
+            unset($params['driver']);
+        }
+
+        $params = $this->parseDatabaseUrlPath($url, $params);
+        $params = $this->parseDatabaseUrlQuery($url, $params);
+
+        return $params;
+    }
+
+    /**
+     * Parses the given connection URL and resolves the given connection parameters.
+     *
+     * Assumes that the connection URL scheme is already parsed and resolved into the given connection parameters
+     * via {@see parseDatabaseUrlScheme}.
+     *
+     * @see parseDatabaseUrlScheme
+     *
+     * @param mixed[] $url    The URL parts to evaluate.
+     * @param mixed[] $params The connection parameters to resolve.
+     *
+     * @return mixed[] The resolved connection parameters.
+     */
+    private function parseDatabaseUrlPath(array $url, array $params): array
+    {
+        if (! isset($url['path'])) {
+            return $params;
+        }
+
+        $url['path'] = $this->normalizeDatabaseUrlPath($url['path']);
+
+        // If we do not have a known DBAL driver, we do not know any connection URL path semantics to evaluate
+        // and therefore treat the path as a regular DBAL connection URL path.
+        if (! isset($params['driver'])) {
+            return $this->parseRegularDatabaseUrlPath($url, $params);
+        }
+
+        if (strpos($params['driver'], 'sqlite') !== false) {
+            return $this->parseSqliteDatabaseUrlPath($url, $params);
+        }
+
+        return $this->parseRegularDatabaseUrlPath($url, $params);
+    }
+
+    /**
+     * Normalizes the given connection URL path.
+     *
+     * @return string The normalized connection URL path
+     */
+    private function normalizeDatabaseUrlPath(string $urlPath): string
+    {
+        // Trim leading slash from URL path.
+        return substr($urlPath, 1);
+    }
+
+    /**
+     * Parses the query part of the given connection URL and resolves the given connection parameters.
+     *
+     * @param mixed[] $url    The connection URL parts to evaluate.
+     * @param mixed[] $params The connection parameters to resolve.
+     *
+     * @return mixed[] The resolved connection parameters.
+     */
+    private function parseDatabaseUrlQuery(array $url, array $params): array
+    {
+        if (! isset($url['query'])) {
+            return $params;
+        }
+
+        $query = [];
+
+        parse_str($url['query'], $query); // simply ingest query as extra params, e.g. charset or sslmode
+
+        return array_merge($params, $query); // parse_str wipes existing array elements
+    }
+
+    /**
+     * Parses the given regular connection URL and resolves the given connection parameters.
+     *
+     * Assumes that the "path" URL part is already normalized via {@see normalizeDatabaseUrlPath}.
+     *
+     * @see normalizeDatabaseUrlPath
+     *
+     * @param mixed[] $url    The regular connection URL parts to evaluate.
+     * @param mixed[] $params The connection parameters to resolve.
+     *
+     * @return mixed[] The resolved connection parameters.
+     */
+    private function parseRegularDatabaseUrlPath(array $url, array $params): array
+    {
+        $params['dbname'] = $url['path'];
+
+        return $params;
+    }
+
+    /**
+     * Parses the given SQLite connection URL and resolves the given connection parameters.
+     *
+     * Assumes that the "path" URL part is already normalized via {@see normalizeDatabaseUrlPath}.
+     *
+     * @see normalizeDatabaseUrlPath
+     *
+     * @param mixed[] $url    The SQLite connection URL parts to evaluate.
+     * @param mixed[] $params The connection parameters to resolve.
+     *
+     * @return mixed[] The resolved connection parameters.
+     */
+    private function parseSqliteDatabaseUrlPath(array $url, array $params): array
+    {
+        if ($url['path'] === ':memory:') {
+            $params['memory'] = true;
+
+            return $params;
+        }
+
+        $params['path'] = $url['path']; // pdo_sqlite driver uses 'path' instead of 'dbname' key
+
+        return $params;
+    }
+
+    /**
+     * Parses the scheme part from given connection URL and resolves the given connection parameters.
+     *
+     * @return string The resolved driver.
+     */
+    private function parseDatabaseUrlScheme(string $scheme): string
+    {
+        // URL schemes must not contain underscores, but dashes are ok
+        $driver = str_replace('-', '_', $scheme);
+
+        // If the driver is an alias (e.g. "postgres"), map it to the actual name ("pdo-pgsql").
+        // Otherwise, let checkParams decide later if the driver exists.
+        return $this->schemeMapping[$driver] ?? $driver;
+    }
+}