├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── composer.json
├── phpstan-baseline.neon
└── src
    ├── ArrayParameterType.php
    ├── ArrayParameters
        ├── Exception.php
        └── Exception
        │   ├── MissingNamedParameter.php
        │   └── MissingPositionalParameter.php
    ├── Cache
        ├── ArrayResult.php
        ├── CacheException.php
        ├── Exception
        │   ├── NoCacheKey.php
        │   └── NoResultDriverConfigured.php
        └── QueryCacheProfile.php
    ├── ColumnCase.php
    ├── Configuration.php
    ├── Connection.php
    ├── Connection
        └── StaticServerVersionProvider.php
    ├── ConnectionException.php
    ├── Connections
        └── PrimaryReadReplicaConnection.php
    ├── Driver.php
    ├── Driver
        ├── API
        │   ├── ExceptionConverter.php
        │   ├── IBMDB2
        │   │   └── ExceptionConverter.php
        │   ├── MySQL
        │   │   └── ExceptionConverter.php
        │   ├── OCI
        │   │   └── ExceptionConverter.php
        │   ├── PostgreSQL
        │   │   └── ExceptionConverter.php
        │   ├── SQLSrv
        │   │   └── ExceptionConverter.php
        │   └── SQLite
        │   │   └── ExceptionConverter.php
        ├── AbstractDB2Driver.php
        ├── AbstractException.php
        ├── AbstractMySQLDriver.php
        ├── AbstractOracleDriver.php
        ├── AbstractOracleDriver
        │   └── EasyConnectString.php
        ├── AbstractPostgreSQLDriver.php
        ├── AbstractSQLServerDriver.php
        ├── AbstractSQLServerDriver
        │   └── Exception
        │   │   └── PortWithoutHost.php
        ├── AbstractSQLiteDriver.php
        ├── AbstractSQLiteDriver
        │   └── Middleware
        │   │   └── EnableForeignKeys.php
        ├── Connection.php
        ├── Exception.php
        ├── Exception
        │   ├── IdentityColumnsNotSupported.php
        │   └── NoIdentityValue.php
        ├── FetchUtils.php
        ├── IBMDB2
        │   ├── Connection.php
        │   ├── DataSourceName.php
        │   ├── Driver.php
        │   ├── Exception
        │   │   ├── CannotCopyStreamToStream.php
        │   │   ├── CannotCreateTemporaryFile.php
        │   │   ├── ConnectionError.php
        │   │   ├── ConnectionFailed.php
        │   │   ├── Factory.php
        │   │   ├── PrepareFailed.php
        │   │   └── StatementError.php
        │   ├── Result.php
        │   └── Statement.php
        ├── Middleware.php
        ├── Middleware
        │   ├── AbstractConnectionMiddleware.php
        │   ├── AbstractDriverMiddleware.php
        │   ├── AbstractResultMiddleware.php
        │   └── AbstractStatementMiddleware.php
        ├── Mysqli
        │   ├── Connection.php
        │   ├── Driver.php
        │   ├── Exception
        │   │   ├── ConnectionError.php
        │   │   ├── ConnectionFailed.php
        │   │   ├── FailedReadingStreamOffset.php
        │   │   ├── HostRequired.php
        │   │   ├── InvalidCharset.php
        │   │   ├── InvalidOption.php
        │   │   ├── NonStreamResourceUsedAsLargeObject.php
        │   │   └── StatementError.php
        │   ├── Initializer.php
        │   ├── Initializer
        │   │   ├── Charset.php
        │   │   ├── Options.php
        │   │   └── Secure.php
        │   ├── Result.php
        │   └── Statement.php
        ├── OCI8
        │   ├── Connection.php
        │   ├── ConvertPositionalToNamedPlaceholders.php
        │   ├── Driver.php
        │   ├── Exception
        │   │   ├── ConnectionFailed.php
        │   │   ├── Error.php
        │   │   ├── InvalidConfiguration.php
        │   │   ├── NonTerminatedStringLiteral.php
        │   │   └── UnknownParameterIndex.php
        │   ├── ExecutionMode.php
        │   ├── Middleware
        │   │   └── InitializeSession.php
        │   ├── Result.php
        │   └── Statement.php
        ├── PDO
        │   ├── Connection.php
        │   ├── Exception.php
        │   ├── Exception
        │   │   └── InvalidConfiguration.php
        │   ├── MySQL
        │   │   └── Driver.php
        │   ├── OCI
        │   │   └── Driver.php
        │   ├── PDOConnect.php
        │   ├── PgSQL
        │   │   └── Driver.php
        │   ├── Result.php
        │   ├── SQLSrv
        │   │   ├── Connection.php
        │   │   ├── Driver.php
        │   │   └── Statement.php
        │   ├── SQLite
        │   │   └── Driver.php
        │   └── Statement.php
        ├── PgSQL
        │   ├── Connection.php
        │   ├── ConvertParameters.php
        │   ├── Driver.php
        │   ├── Exception.php
        │   ├── Exception
        │   │   ├── UnexpectedValue.php
        │   │   └── UnknownParameter.php
        │   ├── Result.php
        │   └── Statement.php
        ├── Result.php
        ├── SQLSrv
        │   ├── Connection.php
        │   ├── Driver.php
        │   ├── Exception
        │   │   └── Error.php
        │   ├── Result.php
        │   └── Statement.php
        ├── SQLite3
        │   ├── Connection.php
        │   ├── Driver.php
        │   ├── Exception.php
        │   ├── Result.php
        │   └── Statement.php
        └── Statement.php
    ├── DriverManager.php
    ├── Exception.php
    ├── Exception
        ├── CommitFailedRollbackOnly.php
        ├── ConnectionException.php
        ├── ConnectionLost.php
        ├── ConstraintViolationException.php
        ├── DatabaseDoesNotExist.php
        ├── DatabaseObjectExistsException.php
        ├── DatabaseObjectNotFoundException.php
        ├── DatabaseRequired.php
        ├── DeadlockException.php
        ├── DriverException.php
        ├── DriverRequired.php
        ├── ForeignKeyConstraintViolationException.php
        ├── InvalidArgumentException.php
        ├── InvalidColumnDeclaration.php
        ├── InvalidColumnIndex.php
        ├── InvalidColumnType.php
        ├── InvalidColumnType
        │   ├── ColumnLengthRequired.php
        │   ├── ColumnPrecisionRequired.php
        │   ├── ColumnScaleRequired.php
        │   └── ColumnValuesRequired.php
        ├── InvalidDriverClass.php
        ├── InvalidFieldNameException.php
        ├── InvalidWrapperClass.php
        ├── LockWaitTimeoutException.php
        ├── MalformedDsnException.php
        ├── NoActiveTransaction.php
        ├── NoKeyValue.php
        ├── NonUniqueFieldNameException.php
        ├── NotNullConstraintViolationException.php
        ├── ReadOnlyException.php
        ├── RetryableException.php
        ├── SavepointsNotSupported.php
        ├── SchemaDoesNotExist.php
        ├── ServerException.php
        ├── SyntaxErrorException.php
        ├── TableExistsException.php
        ├── TableNotFoundException.php
        ├── TransactionRolledBack.php
        ├── UniqueConstraintViolationException.php
        └── UnknownDriver.php
    ├── ExpandArrayParameters.php
    ├── LockMode.php
    ├── Logging
        ├── Connection.php
        ├── Driver.php
        ├── Middleware.php
        └── Statement.php
    ├── ParameterType.php
    ├── Platforms
        ├── AbstractMySQLPlatform.php
        ├── AbstractPlatform.php
        ├── DB2Platform.php
        ├── DateIntervalUnit.php
        ├── Exception
        │   ├── InvalidPlatformVersion.php
        │   ├── NoColumnsSpecifiedForTable.php
        │   ├── NotSupported.php
        │   └── PlatformException.php
        ├── Keywords
        │   ├── DB2Keywords.php
        │   ├── KeywordList.php
        │   ├── MariaDBKeywords.php
        │   ├── MySQL80Keywords.php
        │   ├── MySQL84Keywords.php
        │   ├── MySQLKeywords.php
        │   ├── OracleKeywords.php
        │   ├── PostgreSQLKeywords.php
        │   ├── SQLServerKeywords.php
        │   └── SQLiteKeywords.php
        ├── MariaDB1010Platform.php
        ├── MariaDB1052Platform.php
        ├── MariaDB1060Platform.php
        ├── MariaDBPlatform.php
        ├── MySQL
        │   ├── CharsetMetadataProvider.php
        │   ├── CharsetMetadataProvider
        │   │   ├── CachingCharsetMetadataProvider.php
        │   │   └── ConnectionCharsetMetadataProvider.php
        │   ├── CollationMetadataProvider.php
        │   ├── CollationMetadataProvider
        │   │   ├── CachingCollationMetadataProvider.php
        │   │   └── ConnectionCollationMetadataProvider.php
        │   ├── Comparator.php
        │   └── DefaultTableOptions.php
        ├── MySQL80Platform.php
        ├── MySQL84Platform.php
        ├── MySQLPlatform.php
        ├── OraclePlatform.php
        ├── PostgreSQL120Platform.php
        ├── PostgreSQLPlatform.php
        ├── SQLServer
        │   ├── Comparator.php
        │   └── SQL
        │   │   └── Builder
        │   │       └── SQLServerSelectSQLBuilder.php
        ├── SQLServerPlatform.php
        ├── SQLite
        │   └── Comparator.php
        ├── SQLitePlatform.php
        └── TrimMode.php
    ├── Portability
        ├── Connection.php
        ├── Converter.php
        ├── Driver.php
        ├── Middleware.php
        ├── OptimizeFlags.php
        ├── Result.php
        └── Statement.php
    ├── Query.php
    ├── Query
        ├── Exception
        │   ├── NonUniqueAlias.php
        │   └── UnknownAlias.php
        ├── Expression
        │   ├── CompositeExpression.php
        │   └── ExpressionBuilder.php
        ├── ForUpdate.php
        ├── ForUpdate
        │   └── ConflictResolutionMode.php
        ├── From.php
        ├── Join.php
        ├── Limit.php
        ├── QueryBuilder.php
        ├── QueryException.php
        ├── QueryType.php
        ├── SelectQuery.php
        ├── Union.php
        ├── UnionQuery.php
        └── UnionType.php
    ├── Result.php
    ├── SQL
        ├── Builder
        │   ├── CreateSchemaObjectsSQLBuilder.php
        │   ├── DefaultSelectSQLBuilder.php
        │   ├── DefaultUnionSQLBuilder.php
        │   ├── DropSchemaObjectsSQLBuilder.php
        │   ├── SelectSQLBuilder.php
        │   └── UnionSQLBuilder.php
        ├── Parser.php
        └── Parser
        │   ├── Exception.php
        │   ├── Exception
        │       └── RegularExpressionError.php
        │   └── Visitor.php
    ├── Schema
        ├── AbstractAsset.php
        ├── AbstractSchemaManager.php
        ├── Column.php
        ├── ColumnDiff.php
        ├── Comparator.php
        ├── DB2SchemaManager.php
        ├── DefaultSchemaManagerFactory.php
        ├── Exception
        │   ├── ColumnAlreadyExists.php
        │   ├── ColumnDoesNotExist.php
        │   ├── ForeignKeyDoesNotExist.php
        │   ├── IndexAlreadyExists.php
        │   ├── IndexDoesNotExist.php
        │   ├── IndexNameInvalid.php
        │   ├── InvalidTableName.php
        │   ├── NamespaceAlreadyExists.php
        │   ├── SequenceAlreadyExists.php
        │   ├── SequenceDoesNotExist.php
        │   ├── TableAlreadyExists.php
        │   ├── TableDoesNotExist.php
        │   ├── UniqueConstraintDoesNotExist.php
        │   └── UnknownColumnOption.php
        ├── ForeignKeyConstraint.php
        ├── Identifier.php
        ├── Index.php
        ├── MySQLSchemaManager.php
        ├── OracleSchemaManager.php
        ├── PostgreSQLSchemaManager.php
        ├── SQLServerSchemaManager.php
        ├── SQLiteSchemaManager.php
        ├── Schema.php
        ├── SchemaConfig.php
        ├── SchemaDiff.php
        ├── SchemaException.php
        ├── SchemaManagerFactory.php
        ├── Sequence.php
        ├── Table.php
        ├── TableDiff.php
        ├── UniqueConstraint.php
        └── View.php
    ├── ServerVersionProvider.php
    ├── Statement.php
    ├── Tools
        ├── Console
        │   ├── Command
        │   │   └── RunSqlCommand.php
        │   ├── ConnectionNotFound.php
        │   ├── ConnectionProvider.php
        │   └── ConnectionProvider
        │   │   └── SingleConnectionProvider.php
        └── DsnParser.php
    ├── TransactionIsolationLevel.php
    └── Types
        ├── AsciiStringType.php
        ├── BigIntType.php
        ├── BinaryType.php
        ├── BlobType.php
        ├── BooleanType.php
        ├── ConversionException.php
        ├── DateImmutableType.php
        ├── DateIntervalType.php
        ├── DateTimeImmutableType.php
        ├── DateTimeType.php
        ├── DateTimeTzImmutableType.php
        ├── DateTimeTzType.php
        ├── DateType.php
        ├── DecimalType.php
        ├── EnumType.php
        ├── Exception
            ├── InvalidFormat.php
            ├── InvalidType.php
            ├── SerializationFailed.php
            ├── TypeAlreadyRegistered.php
            ├── TypeNotFound.php
            ├── TypeNotRegistered.php
            ├── TypesAlreadyExists.php
            ├── TypesException.php
            ├── UnknownColumnType.php
            └── ValueNotConvertible.php
        ├── FloatType.php
        ├── GuidType.php
        ├── IntegerType.php
        ├── JsonType.php
        ├── PhpDateMappingType.php
        ├── PhpDateTimeMappingType.php
        ├── PhpIntegerMappingType.php
        ├── PhpTimeMappingType.php
        ├── SimpleArrayType.php
        ├── SmallFloatType.php
        ├── SmallIntType.php
        ├── StringType.php
        ├── TextType.php
        ├── TimeImmutableType.php
        ├── TimeType.php
        ├── Type.php
        ├── TypeRegistry.php
        ├── Types.php
        ├── VarDateTimeImmutableType.php
        └── VarDateTimeType.php


/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | This repository has [guidelines specific to testing][testing guidelines], and
2 | Doctrine has [general contributing guidelines][contributor workflow], make
3 | sure you follow both.
4 | 
5 | [contributor workflow]: https://www.doctrine-project.org/contribute/index.html
6 | [testing guidelines]: https://www.doctrine-project.org/projects/doctrine-dbal/en/stable/reference/testing.html
7 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2006-2018 Doctrine Project
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | this software and associated documentation files (the "Software"), to deal in
 5 | the Software without restriction, including without limitation the rights to
 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 7 | of the Software, and to permit persons to whom the Software is furnished to do
 8 | so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/src/ArrayParameterType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | enum ArrayParameterType
 8 | {
 9 |     /**
10 |      * Represents an array of ints to be expanded by Doctrine SQL parsing.
11 |      */
12 |     case INTEGER;
13 | 
14 |     /**
15 |      * Represents an array of strings to be expanded by Doctrine SQL parsing.
16 |      */
17 |     case STRING;
18 | 
19 |     /**
20 |      * Represents an array of ascii strings to be expanded by Doctrine SQL parsing.
21 |      */
22 |     case ASCII;
23 | 
24 |     /**
25 |      * Represents an array of ascii strings to be expanded by Doctrine SQL parsing.
26 |      */
27 |     case BINARY;
28 | 
29 |     /** @internal */
30 |     public static function toElementParameterType(self $type): ParameterType
31 |     {
32 |         return match ($type) {
33 |             self::INTEGER => ParameterType::INTEGER,
34 |             self::STRING => ParameterType::STRING,
35 |             self::ASCII => ParameterType::ASCII,
36 |             self::BINARY => ParameterType::BINARY,
37 |         };
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/ArrayParameters/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\ArrayParameters;
 6 | 
 7 | use Throwable;
 8 | 
 9 | /** @internal */
10 | interface Exception extends Throwable
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/ArrayParameters/Exception/MissingNamedParameter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\ArrayParameters\Exception;
 6 | 
 7 | use Doctrine\DBAL\ArrayParameters\Exception;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | class MissingNamedParameter extends LogicException implements Exception
13 | {
14 |     public static function new(string $name): self
15 |     {
16 |         return new self(
17 |             sprintf('Named parameter "%s" does not have a bound value.', $name),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/ArrayParameters/Exception/MissingPositionalParameter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\ArrayParameters\Exception;
 6 | 
 7 | use Doctrine\DBAL\ArrayParameters\Exception;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | /** @internal */
13 | class MissingPositionalParameter extends LogicException implements Exception
14 | {
15 |     public static function new(int $index): self
16 |     {
17 |         return new self(
18 |             sprintf('Positional parameter at index %d does not have a bound value.', $index),
19 |         );
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Cache/CacheException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Cache;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | 
 9 | class CacheException extends \Exception implements Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Cache/Exception/NoCacheKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Cache\Exception;
 6 | 
 7 | use Doctrine\DBAL\Cache\CacheException;
 8 | 
 9 | final class NoCacheKey extends CacheException
10 | {
11 |     public static function new(): self
12 |     {
13 |         return new self('No cache key was set.');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Cache/Exception/NoResultDriverConfigured.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Cache\Exception;
 6 | 
 7 | use Doctrine\DBAL\Cache\CacheException;
 8 | 
 9 | final class NoResultDriverConfigured extends CacheException
10 | {
11 |     public static function new(): self
12 |     {
13 |         return new self('Trying to cache a query but no result driver is configured.');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/ColumnCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | /**
 8 |  * Contains portable column case conversions.
 9 |  */
10 | enum ColumnCase
11 | {
12 |     /**
13 |      * Convert column names to upper case.
14 |      */
15 |     case UPPER;
16 | 
17 |     /**
18 |      * Convert column names to lower case.
19 |      */
20 |     case LOWER;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Connection/StaticServerVersionProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Connection;
 6 | 
 7 | use Doctrine\DBAL\ServerVersionProvider;
 8 | 
 9 | class StaticServerVersionProvider implements ServerVersionProvider
10 | {
11 |     public function __construct(private readonly string $version)
12 |     {
13 |     }
14 | 
15 |     public function getServerVersion(): string
16 |     {
17 |         return $this->version;
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/ConnectionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | class ConnectionException extends \Exception implements Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Driver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | use Doctrine\DBAL\Driver\API\ExceptionConverter;
 8 | use Doctrine\DBAL\Driver\Connection as DriverConnection;
 9 | use Doctrine\DBAL\Driver\Exception;
10 | use Doctrine\DBAL\Platforms\AbstractPlatform;
11 | use SensitiveParameter;
12 | 
13 | /**
14 |  * Driver interface.
15 |  * Interface that all DBAL drivers must implement.
16 |  *
17 |  * @phpstan-import-type Params from DriverManager
18 |  */
19 | interface Driver
20 | {
21 |     /**
22 |      * Attempts to create a connection with the database.
23 |      *
24 |      * @param array<string, mixed> $params All connection parameters.
25 |      * @phpstan-param Params $params All connection parameters.
26 |      *
27 |      * @return DriverConnection The database connection.
28 |      *
29 |      * @throws Exception
30 |      */
31 |     public function connect(
32 |         #[SensitiveParameter]
33 |         array $params,
34 |     ): DriverConnection;
35 | 
36 |     /**
37 |      * Gets the DatabasePlatform instance that provides all the metadata about
38 |      * the platform this driver connects to.
39 |      *
40 |      * @return AbstractPlatform The database platform.
41 |      */
42 |     public function getDatabasePlatform(ServerVersionProvider $versionProvider): AbstractPlatform;
43 | 
44 |     /**
45 |      * Gets the ExceptionConverter that can be used to convert driver-level exceptions into DBAL exceptions.
46 |      */
47 |     public function getExceptionConverter(): ExceptionConverter;
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Driver/API/ExceptionConverter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\API;
 6 | 
 7 | use Doctrine\DBAL\Driver\Exception;
 8 | use Doctrine\DBAL\Exception\DriverException;
 9 | use Doctrine\DBAL\Query;
10 | 
11 | interface ExceptionConverter
12 | {
13 |     /**
14 |      * Converts a given driver-level exception into a DBAL-level driver exception.
15 |      *
16 |      * Implementors should use the vendor-specific error code and SQLSTATE of the exception
17 |      * and instantiate the most appropriate specialized {@see DriverException} subclass.
18 |      *
19 |      * @param Exception  $exception The driver exception to convert.
20 |      * @param Query|null $query     The SQL query that triggered the exception, if any.
21 |      *
22 |      * @return DriverException An instance of {@see DriverException} or one of its subclasses.
23 |      */
24 |     public function convert(Exception $exception, ?Query $query): DriverException;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Driver/API/IBMDB2/ExceptionConverter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\API\IBMDB2;
 6 | 
 7 | use Doctrine\DBAL\Driver\API\ExceptionConverter as ExceptionConverterInterface;
 8 | use Doctrine\DBAL\Driver\Exception;
 9 | use Doctrine\DBAL\Exception\ConnectionException;
10 | use Doctrine\DBAL\Exception\DriverException;
11 | use Doctrine\DBAL\Exception\ForeignKeyConstraintViolationException;
12 | use Doctrine\DBAL\Exception\InvalidFieldNameException;
13 | use Doctrine\DBAL\Exception\NonUniqueFieldNameException;
14 | use Doctrine\DBAL\Exception\NotNullConstraintViolationException;
15 | use Doctrine\DBAL\Exception\SyntaxErrorException;
16 | use Doctrine\DBAL\Exception\TableExistsException;
17 | use Doctrine\DBAL\Exception\TableNotFoundException;
18 | use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
19 | use Doctrine\DBAL\Query;
20 | 
21 | /**
22 |  * @internal
23 |  *
24 |  * @link https://www.ibm.com/docs/en/db2/11.5?topic=messages-sql
25 |  */
26 | final class ExceptionConverter implements ExceptionConverterInterface
27 | {
28 |     public function convert(Exception $exception, ?Query $query): DriverException
29 |     {
30 |         return match ($exception->getCode()) {
31 |             -104 => new SyntaxErrorException($exception, $query),
32 |             -203 => new NonUniqueFieldNameException($exception, $query),
33 |             -204 => new TableNotFoundException($exception, $query),
34 |             -206 => new InvalidFieldNameException($exception, $query),
35 |             -407 => new NotNullConstraintViolationException($exception, $query),
36 |             -530,
37 |             -531,
38 |             -532,
39 |             -20356 => new ForeignKeyConstraintViolationException($exception, $query),
40 |             -601 => new TableExistsException($exception, $query),
41 |             -803 => new UniqueConstraintViolationException($exception, $query),
42 |             -1336,
43 |             -30082 => new ConnectionException($exception, $query),
44 |             default => new DriverException($exception, $query),
45 |         };
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Driver/AbstractDB2Driver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | use Doctrine\DBAL\Driver\API\ExceptionConverter as ExceptionConverterInterface;
 9 | use Doctrine\DBAL\Driver\API\IBMDB2\ExceptionConverter;
10 | use Doctrine\DBAL\Platforms\DB2Platform;
11 | use Doctrine\DBAL\ServerVersionProvider;
12 | 
13 | /**
14 |  * Abstract base implementation of the {@see Driver} interface for IBM DB2 based drivers.
15 |  */
16 | abstract class AbstractDB2Driver implements Driver
17 | {
18 |     public function getDatabasePlatform(ServerVersionProvider $versionProvider): DB2Platform
19 |     {
20 |         return new DB2Platform();
21 |     }
22 | 
23 |     public function getExceptionConverter(): ExceptionConverterInterface
24 |     {
25 |         return new ExceptionConverter();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Driver/AbstractException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | use Exception as BaseException;
 8 | use Throwable;
 9 | 
10 | /**
11 |  * Abstract base implementation of the {@see DriverException} interface.
12 |  */
13 | abstract class AbstractException extends BaseException implements Exception
14 | {
15 |     /**
16 |      * @param string         $message  The driver error message.
17 |      * @param string|null    $sqlState The SQLSTATE the driver is in at the time the error occurred, if any.
18 |      * @param int            $code     The driver specific error code if any.
19 |      * @param Throwable|null $previous The previous throwable used for the exception chaining.
20 |      */
21 |     public function __construct(
22 |         string $message,
23 |         private readonly ?string $sqlState = null,
24 |         int $code = 0,
25 |         ?Throwable $previous = null,
26 |     ) {
27 |         parent::__construct($message, $code, $previous);
28 |     }
29 | 
30 |     public function getSQLState(): ?string
31 |     {
32 |         return $this->sqlState;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Driver/AbstractOracleDriver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | use Doctrine\DBAL\Driver\AbstractOracleDriver\EasyConnectString;
 9 | use Doctrine\DBAL\Driver\API\ExceptionConverter as ExceptionConverterInterface;
10 | use Doctrine\DBAL\Driver\API\OCI\ExceptionConverter;
11 | use Doctrine\DBAL\Platforms\OraclePlatform;
12 | use Doctrine\DBAL\ServerVersionProvider;
13 | 
14 | /**
15 |  * Abstract base implementation of the {@see Driver} interface for Oracle based drivers.
16 |  */
17 | abstract class AbstractOracleDriver implements Driver
18 | {
19 |     public function getDatabasePlatform(ServerVersionProvider $versionProvider): OraclePlatform
20 |     {
21 |         return new OraclePlatform();
22 |     }
23 | 
24 |     public function getExceptionConverter(): ExceptionConverterInterface
25 |     {
26 |         return new ExceptionConverter();
27 |     }
28 | 
29 |     /**
30 |      * Returns an appropriate Easy Connect String for the given parameters.
31 |      *
32 |      * @param array<string, mixed> $params The connection parameters to return the Easy Connect String for.
33 |      */
34 |     protected function getEasyConnectString(array $params): string
35 |     {
36 |         return (string) EasyConnectString::fromConnectionParameters($params);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Driver/AbstractPostgreSQLDriver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | use Doctrine\DBAL\Driver\API\ExceptionConverter as ExceptionConverterInterface;
 9 | use Doctrine\DBAL\Driver\API\PostgreSQL\ExceptionConverter;
10 | use Doctrine\DBAL\Platforms\Exception\InvalidPlatformVersion;
11 | use Doctrine\DBAL\Platforms\PostgreSQL120Platform;
12 | use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
13 | use Doctrine\DBAL\ServerVersionProvider;
14 | use Doctrine\Deprecations\Deprecation;
15 | 
16 | use function preg_match;
17 | use function version_compare;
18 | 
19 | /**
20 |  * Abstract base implementation of the {@see Driver} interface for PostgreSQL based drivers.
21 |  */
22 | abstract class AbstractPostgreSQLDriver implements Driver
23 | {
24 |     public function getDatabasePlatform(ServerVersionProvider $versionProvider): PostgreSQLPlatform
25 |     {
26 |         $version = $versionProvider->getServerVersion();
27 | 
28 |         if (preg_match('/^(?P<major>\d+)(?:\.(?P<minor>\d+)(?:\.(?P<patch>\d+))?)?/', $version, $versionParts) !== 1) {
29 |             throw InvalidPlatformVersion::new(
30 |                 $version,
31 |                 '<major_version>.<minor_version>.<patch_version>',
32 |             );
33 |         }
34 | 
35 |         $majorVersion = $versionParts['major'];
36 |         $minorVersion = $versionParts['minor'] ?? 0;
37 |         $patchVersion = $versionParts['patch'] ?? 0;
38 |         $version      = $majorVersion . '.' . $minorVersion . '.' . $patchVersion;
39 | 
40 |         if (version_compare($version, '12.0', '>=')) {
41 |             return new PostgreSQL120Platform();
42 |         }
43 | 
44 |         Deprecation::trigger(
45 |             'doctrine/dbal',
46 |             'https://github.com/doctrine/dbal/pull/6495',
47 |             'Support for Postgres < 12 is deprecated and will be removed in DBAL 5',
48 |         );
49 | 
50 |         return new PostgreSQLPlatform();
51 |     }
52 | 
53 |     public function getExceptionConverter(): ExceptionConverterInterface
54 |     {
55 |         return new ExceptionConverter();
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Driver/AbstractSQLServerDriver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | use Doctrine\DBAL\Driver\API\ExceptionConverter as ExceptionConverterInterface;
 9 | use Doctrine\DBAL\Driver\API\SQLSrv\ExceptionConverter;
10 | use Doctrine\DBAL\Platforms\SQLServerPlatform;
11 | use Doctrine\DBAL\ServerVersionProvider;
12 | 
13 | /**
14 |  * Abstract base implementation of the {@see Driver} interface for Microsoft SQL Server based drivers.
15 |  */
16 | abstract class AbstractSQLServerDriver implements Driver
17 | {
18 |     public function getDatabasePlatform(ServerVersionProvider $versionProvider): SQLServerPlatform
19 |     {
20 |         return new SQLServerPlatform();
21 |     }
22 | 
23 |     public function getExceptionConverter(): ExceptionConverterInterface
24 |     {
25 |         return new ExceptionConverter();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Driver/AbstractSQLServerDriver/Exception/PortWithoutHost.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\AbstractSQLServerDriver\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | /** @internal */
10 | final class PortWithoutHost extends AbstractException
11 | {
12 |     public static function new(): self
13 |     {
14 |         return new self('Connection port specified without the host');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Driver/AbstractSQLiteDriver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | use Doctrine\DBAL\Driver\API\ExceptionConverter as ExceptionConverterInterface;
 9 | use Doctrine\DBAL\Driver\API\SQLite\ExceptionConverter;
10 | use Doctrine\DBAL\Platforms\SQLitePlatform;
11 | use Doctrine\DBAL\ServerVersionProvider;
12 | 
13 | /**
14 |  * Abstract base implementation of the {@see Driver} interface for SQLite based drivers.
15 |  */
16 | abstract class AbstractSQLiteDriver implements Driver
17 | {
18 |     public function getDatabasePlatform(ServerVersionProvider $versionProvider): SQLitePlatform
19 |     {
20 |         return new SQLitePlatform();
21 |     }
22 | 
23 |     public function getExceptionConverter(): ExceptionConverterInterface
24 |     {
25 |         return new ExceptionConverter();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Driver/AbstractSQLiteDriver/Middleware/EnableForeignKeys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\AbstractSQLiteDriver\Middleware;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | use Doctrine\DBAL\Driver\Connection;
 9 | use Doctrine\DBAL\Driver\Middleware;
10 | use Doctrine\DBAL\Driver\Middleware\AbstractDriverMiddleware;
11 | use SensitiveParameter;
12 | 
13 | final class EnableForeignKeys implements Middleware
14 | {
15 |     public function wrap(Driver $driver): Driver
16 |     {
17 |         return new class ($driver) extends AbstractDriverMiddleware {
18 |             /**
19 |              * {@inheritDoc}
20 |              */
21 |             public function connect(
22 |                 #[SensitiveParameter]
23 |                 array $params,
24 |             ): Connection {
25 |                 $connection = parent::connect($params);
26 | 
27 |                 $connection->exec('PRAGMA foreign_keys=ON');
28 | 
29 |                 return $connection;
30 |             }
31 |         };
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Driver/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | use Throwable;
 8 | 
 9 | /**
10 |  * Contract for a driver exception.
11 |  *
12 |  * Driver exceptions provide the SQLSTATE of the driver
13 |  * and the driver specific error code at the time the error occurred.
14 |  */
15 | interface Exception extends Throwable
16 | {
17 |     /**
18 |      * Returns the SQLSTATE the driver was in at the time the error occurred.
19 |      *
20 |      * Returns null if the driver does not provide a SQLSTATE for the error occurred.
21 |      */
22 |     public function getSQLState(): ?string;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Driver/Exception/IdentityColumnsNotSupported.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | use Throwable;
 9 | 
10 | /** @internal */
11 | final class IdentityColumnsNotSupported extends AbstractException
12 | {
13 |     public static function new(?Throwable $previous = null): self
14 |     {
15 |         return new self('The driver does not support identity columns.', null, 0, $previous);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Driver/Exception/NoIdentityValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | use Throwable;
 9 | 
10 | /** @internal */
11 | final class NoIdentityValue extends AbstractException
12 | {
13 |     public static function new(?Throwable $previous = null): self
14 |     {
15 |         return new self('No identity value was generated by the last statement.', null, 0, $previous);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Driver/FetchUtils.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | /** @internal */
 8 | final class FetchUtils
 9 | {
10 |     /** @throws Exception */
11 |     public static function fetchOne(Result $result): mixed
12 |     {
13 |         $row = $result->fetchNumeric();
14 | 
15 |         if ($row === false) {
16 |             return false;
17 |         }
18 | 
19 |         return $row[0];
20 |     }
21 | 
22 |     /**
23 |      * @return list<list<mixed>>
24 |      *
25 |      * @throws Exception
26 |      */
27 |     public static function fetchAllNumeric(Result $result): array
28 |     {
29 |         $rows = [];
30 | 
31 |         while (($row = $result->fetchNumeric()) !== false) {
32 |             $rows[] = $row;
33 |         }
34 | 
35 |         return $rows;
36 |     }
37 | 
38 |     /**
39 |      * @return list<array<string,mixed>>
40 |      *
41 |      * @throws Exception
42 |      */
43 |     public static function fetchAllAssociative(Result $result): array
44 |     {
45 |         $rows = [];
46 | 
47 |         while (($row = $result->fetchAssociative()) !== false) {
48 |             $rows[] = $row;
49 |         }
50 | 
51 |         return $rows;
52 |     }
53 | 
54 |     /**
55 |      * @return list<mixed>
56 |      *
57 |      * @throws Exception
58 |      */
59 |     public static function fetchFirstColumn(Result $result): array
60 |     {
61 |         $rows = [];
62 | 
63 |         while (($row = $result->fetchOne()) !== false) {
64 |             $rows[] = $row;
65 |         }
66 | 
67 |         return $rows;
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Driver/IBMDB2/DataSourceName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\IBMDB2;
 6 | 
 7 | use SensitiveParameter;
 8 | 
 9 | use function implode;
10 | use function sprintf;
11 | use function str_contains;
12 | 
13 | /**
14 |  * IBM DB2 DSN
15 |  */
16 | final class DataSourceName
17 | {
18 |     private function __construct(
19 |         #[SensitiveParameter]
20 |         private readonly string $string,
21 |     ) {
22 |     }
23 | 
24 |     public function toString(): string
25 |     {
26 |         return $this->string;
27 |     }
28 | 
29 |     /**
30 |      * Creates the object from an array representation
31 |      *
32 |      * @param array<string,mixed> $params
33 |      */
34 |     public static function fromArray(
35 |         #[SensitiveParameter]
36 |         array $params,
37 |     ): self {
38 |         $chunks = [];
39 | 
40 |         foreach ($params as $key => $value) {
41 |             $chunks[] = sprintf('%s=%s', $key, $value);
42 |         }
43 | 
44 |         return new self(implode(';', $chunks));
45 |     }
46 | 
47 |     /**
48 |      * Creates the object from the given DBAL connection parameters.
49 |      *
50 |      * @param array<string,mixed> $params
51 |      */
52 |     public static function fromConnectionParameters(#[SensitiveParameter]
53 |     array $params,): self
54 |     {
55 |         if (isset($params['dbname']) && str_contains($params['dbname'], '=')) {
56 |             return new self($params['dbname']);
57 |         }
58 | 
59 |         $dsnParams = [];
60 | 
61 |         foreach (
62 |             [
63 |                 'host'     => 'HOSTNAME',
64 |                 'port'     => 'PORT',
65 |                 'protocol' => 'PROTOCOL',
66 |                 'dbname'   => 'DATABASE',
67 |                 'user'     => 'UID',
68 |                 'password' => 'PWD',
69 |             ] as $dbalParam => $dsnParam
70 |         ) {
71 |             if (! isset($params[$dbalParam])) {
72 |                 continue;
73 |             }
74 | 
75 |             $dsnParams[$dsnParam] = $params[$dbalParam];
76 |         }
77 | 
78 |         return self::fromArray($dsnParams);
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/Driver/IBMDB2/Driver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\IBMDB2;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractDB2Driver;
 8 | use Doctrine\DBAL\Driver\IBMDB2\Exception\ConnectionFailed;
 9 | use SensitiveParameter;
10 | 
11 | use function db2_connect;
12 | use function db2_pconnect;
13 | 
14 | final class Driver extends AbstractDB2Driver
15 | {
16 |     /**
17 |      * {@inheritDoc}
18 |      */
19 |     public function connect(
20 |         #[SensitiveParameter]
21 |         array $params,
22 |     ): Connection {
23 |         $dataSourceName = DataSourceName::fromConnectionParameters($params)->toString();
24 | 
25 |         $username      = $params['user'] ?? '';
26 |         $password      = $params['password'] ?? '';
27 |         $driverOptions = $params['driverOptions'] ?? [];
28 | 
29 |         if (! empty($params['persistent'])) {
30 |             $connection = db2_pconnect($dataSourceName, $username, $password, $driverOptions);
31 |         } else {
32 |             $connection = db2_connect($dataSourceName, $username, $password, $driverOptions);
33 |         }
34 | 
35 |         if ($connection === false) {
36 |             throw ConnectionFailed::new();
37 |         }
38 | 
39 |         return new Connection($connection);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Driver/IBMDB2/Exception/CannotCopyStreamToStream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\IBMDB2\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | /** @internal */
10 | final class CannotCopyStreamToStream extends AbstractException
11 | {
12 |     /** @phpstan-param array{message: string, ...}|null $error */
13 |     public static function new(?array $error): self
14 |     {
15 |         $message = 'Could not copy source stream to temporary file';
16 | 
17 |         if ($error !== null) {
18 |             $message .= ': ' . $error['message'];
19 |         }
20 | 
21 |         return new self($message);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Driver/IBMDB2/Exception/CannotCreateTemporaryFile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\IBMDB2\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | /** @internal */
10 | final class CannotCreateTemporaryFile extends AbstractException
11 | {
12 |     /** @phpstan-param array{message: string, ...}|null $error */
13 |     public static function new(?array $error): self
14 |     {
15 |         $message = 'Could not create temporary file';
16 | 
17 |         if ($error !== null) {
18 |             $message .= ': ' . $error['message'];
19 |         }
20 | 
21 |         return new self($message);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Driver/IBMDB2/Exception/ConnectionError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\IBMDB2\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function db2_conn_error;
10 | use function db2_conn_errormsg;
11 | 
12 | /** @internal */
13 | final class ConnectionError extends AbstractException
14 | {
15 |     /** @param resource $connection */
16 |     public static function new($connection): self
17 |     {
18 |         $message  = db2_conn_errormsg($connection);
19 |         $sqlState = db2_conn_error($connection);
20 | 
21 |         return Factory::create($message, static function (int $code) use ($message, $sqlState): self {
22 |             return new self($message, $sqlState, $code);
23 |         });
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Driver/IBMDB2/Exception/ConnectionFailed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\IBMDB2\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function db2_conn_error;
10 | use function db2_conn_errormsg;
11 | 
12 | /** @internal */
13 | final class ConnectionFailed extends AbstractException
14 | {
15 |     public static function new(): self
16 |     {
17 |         $message  = db2_conn_errormsg();
18 |         $sqlState = db2_conn_error();
19 | 
20 |         return Factory::create($message, static function (int $code) use ($message, $sqlState): self {
21 |             return new self($message, $sqlState, $code);
22 |         });
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Driver/IBMDB2/Exception/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\IBMDB2\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function preg_match;
10 | 
11 | /** @internal */
12 | final class Factory
13 | {
14 |     /**
15 |      * @param callable(int): T $constructor
16 |      *
17 |      * @return T
18 |      *
19 |      * @template T of AbstractException
20 |      */
21 |     public static function create(string $message, callable $constructor): AbstractException
22 |     {
23 |         $code = 0;
24 | 
25 |         if (preg_match('/ SQL(\d+)N /', $message, $matches) === 1) {
26 |             $code = -(int) $matches[1];
27 |         }
28 | 
29 |         return $constructor($code);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Driver/IBMDB2/Exception/PrepareFailed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\IBMDB2\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | /** @internal */
10 | final class PrepareFailed extends AbstractException
11 | {
12 |     /** @phpstan-param array{message: string, ...}|null $error */
13 |     public static function new(?array $error): self
14 |     {
15 |         if ($error === null) {
16 |             return new self('Unknown error');
17 |         }
18 | 
19 |         return new self($error['message']);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Driver/IBMDB2/Exception/StatementError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\IBMDB2\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function db2_stmt_error;
10 | use function db2_stmt_errormsg;
11 | 
12 | /** @internal */
13 | final class StatementError extends AbstractException
14 | {
15 |     /** @param resource|null $statement */
16 |     public static function new($statement = null): self
17 |     {
18 |         if ($statement !== null) {
19 |             $message  = db2_stmt_errormsg($statement);
20 |             $sqlState = db2_stmt_error($statement);
21 |         } else {
22 |             $message  = db2_stmt_errormsg();
23 |             $sqlState = db2_stmt_error();
24 |         }
25 | 
26 |         return Factory::create($message, static function (int $code) use ($message, $sqlState): self {
27 |             return new self($message, $sqlState, $code);
28 |         });
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Driver/Middleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | 
 9 | interface Middleware
10 | {
11 |     public function wrap(Driver $driver): Driver;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Driver/Middleware/AbstractConnectionMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Middleware;
 6 | 
 7 | use Doctrine\DBAL\Driver\Connection;
 8 | use Doctrine\DBAL\Driver\Result;
 9 | use Doctrine\DBAL\Driver\Statement;
10 | 
11 | abstract class AbstractConnectionMiddleware implements Connection
12 | {
13 |     public function __construct(private readonly Connection $wrappedConnection)
14 |     {
15 |     }
16 | 
17 |     public function prepare(string $sql): Statement
18 |     {
19 |         return $this->wrappedConnection->prepare($sql);
20 |     }
21 | 
22 |     public function query(string $sql): Result
23 |     {
24 |         return $this->wrappedConnection->query($sql);
25 |     }
26 | 
27 |     public function quote(string $value): string
28 |     {
29 |         return $this->wrappedConnection->quote($value);
30 |     }
31 | 
32 |     public function exec(string $sql): int|string
33 |     {
34 |         return $this->wrappedConnection->exec($sql);
35 |     }
36 | 
37 |     public function lastInsertId(): int|string
38 |     {
39 |         return $this->wrappedConnection->lastInsertId();
40 |     }
41 | 
42 |     public function beginTransaction(): void
43 |     {
44 |         $this->wrappedConnection->beginTransaction();
45 |     }
46 | 
47 |     public function commit(): void
48 |     {
49 |         $this->wrappedConnection->commit();
50 |     }
51 | 
52 |     public function rollBack(): void
53 |     {
54 |         $this->wrappedConnection->rollBack();
55 |     }
56 | 
57 |     public function getServerVersion(): string
58 |     {
59 |         return $this->wrappedConnection->getServerVersion();
60 |     }
61 | 
62 |     /**
63 |      * {@inheritDoc}
64 |      */
65 |     public function getNativeConnection()
66 |     {
67 |         return $this->wrappedConnection->getNativeConnection();
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Driver/Middleware/AbstractDriverMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Middleware;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | use Doctrine\DBAL\Driver\API\ExceptionConverter;
 9 | use Doctrine\DBAL\Driver\Connection as DriverConnection;
10 | use Doctrine\DBAL\Platforms\AbstractPlatform;
11 | use Doctrine\DBAL\ServerVersionProvider;
12 | use SensitiveParameter;
13 | 
14 | abstract class AbstractDriverMiddleware implements Driver
15 | {
16 |     public function __construct(private readonly Driver $wrappedDriver)
17 |     {
18 |     }
19 | 
20 |     /**
21 |      * {@inheritDoc}
22 |      */
23 |     public function connect(
24 |         #[SensitiveParameter]
25 |         array $params,
26 |     ): DriverConnection {
27 |         return $this->wrappedDriver->connect($params);
28 |     }
29 | 
30 |     public function getDatabasePlatform(ServerVersionProvider $versionProvider): AbstractPlatform
31 |     {
32 |         return $this->wrappedDriver->getDatabasePlatform($versionProvider);
33 |     }
34 | 
35 |     public function getExceptionConverter(): ExceptionConverter
36 |     {
37 |         return $this->wrappedDriver->getExceptionConverter();
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Driver/Middleware/AbstractStatementMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Middleware;
 6 | 
 7 | use Doctrine\DBAL\Driver\Result;
 8 | use Doctrine\DBAL\Driver\Statement;
 9 | use Doctrine\DBAL\ParameterType;
10 | 
11 | abstract class AbstractStatementMiddleware implements Statement
12 | {
13 |     public function __construct(private readonly Statement $wrappedStatement)
14 |     {
15 |     }
16 | 
17 |     public function bindValue(int|string $param, mixed $value, ParameterType $type): void
18 |     {
19 |         $this->wrappedStatement->bindValue($param, $value, $type);
20 |     }
21 | 
22 |     public function execute(): Result
23 |     {
24 |         return $this->wrappedStatement->execute();
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Exception/ConnectionError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | use mysqli;
 9 | use mysqli_sql_exception;
10 | use ReflectionProperty;
11 | 
12 | /** @internal */
13 | final class ConnectionError extends AbstractException
14 | {
15 |     public static function new(mysqli $connection): self
16 |     {
17 |         return new self($connection->error, $connection->sqlstate, $connection->errno);
18 |     }
19 | 
20 |     public static function upcast(mysqli_sql_exception $exception): self
21 |     {
22 |         $p = new ReflectionProperty(mysqli_sql_exception::class, 'sqlstate');
23 | 
24 |         return new self($exception->getMessage(), $p->getValue($exception), $exception->getCode(), $exception);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Exception/ConnectionFailed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | use mysqli;
 9 | use mysqli_sql_exception;
10 | use ReflectionProperty;
11 | 
12 | use function assert;
13 | 
14 | /** @internal */
15 | final class ConnectionFailed extends AbstractException
16 | {
17 |     public static function new(mysqli $connection): self
18 |     {
19 |         $error = $connection->connect_error;
20 |         assert($error !== null);
21 | 
22 |         return new self($error, 'HY000', $connection->connect_errno);
23 |     }
24 | 
25 |     public static function upcast(mysqli_sql_exception $exception): self
26 |     {
27 |         $p = new ReflectionProperty(mysqli_sql_exception::class, 'sqlstate');
28 | 
29 |         return new self($exception->getMessage(), $p->getValue($exception), $exception->getCode(), $exception);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Exception/FailedReadingStreamOffset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function sprintf;
10 | 
11 | /** @internal */
12 | final class FailedReadingStreamOffset extends AbstractException
13 | {
14 |     public static function new(int $parameter): self
15 |     {
16 |         return new self(sprintf('Failed reading the stream resource for parameter #%d.', $parameter));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Exception/HostRequired.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | /** @internal */
10 | final class HostRequired extends AbstractException
11 | {
12 |     public static function forPersistentConnection(): self
13 |     {
14 |         return new self('The "host" parameter is required for a persistent connection');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Exception/InvalidCharset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | use mysqli;
 9 | use mysqli_sql_exception;
10 | use ReflectionProperty;
11 | 
12 | use function sprintf;
13 | 
14 | /** @internal */
15 | final class InvalidCharset extends AbstractException
16 | {
17 |     public static function fromCharset(mysqli $connection, string $charset): self
18 |     {
19 |         return new self(
20 |             sprintf('Failed to set charset "%s": %s', $charset, $connection->error),
21 |             $connection->sqlstate,
22 |             $connection->errno,
23 |         );
24 |     }
25 | 
26 |     public static function upcast(mysqli_sql_exception $exception, string $charset): self
27 |     {
28 |         $p = new ReflectionProperty(mysqli_sql_exception::class, 'sqlstate');
29 | 
30 |         return new self(
31 |             sprintf('Failed to set charset "%s": %s', $charset, $exception->getMessage()),
32 |             $p->getValue($exception),
33 |             $exception->getCode(),
34 |             $exception,
35 |         );
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Exception/InvalidOption.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function sprintf;
10 | 
11 | /** @internal */
12 | final class InvalidOption extends AbstractException
13 | {
14 |     public static function fromOption(int $option, mixed $value): self
15 |     {
16 |         return new self(
17 |             sprintf('Failed to set option %d with value "%s"', $option, $value),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Exception/NonStreamResourceUsedAsLargeObject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function sprintf;
10 | 
11 | /** @internal */
12 | final class NonStreamResourceUsedAsLargeObject extends AbstractException
13 | {
14 |     public static function new(int $parameter): self
15 |     {
16 |         return new self(
17 |             sprintf('The resource passed as a LARGE_OBJECT parameter #%d must be of type "stream"', $parameter),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Exception/StatementError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | use mysqli_sql_exception;
 9 | use mysqli_stmt;
10 | use ReflectionProperty;
11 | 
12 | /** @internal */
13 | final class StatementError extends AbstractException
14 | {
15 |     public static function new(mysqli_stmt $statement): self
16 |     {
17 |         return new self($statement->error, $statement->sqlstate, $statement->errno);
18 |     }
19 | 
20 |     public static function upcast(mysqli_sql_exception $exception): self
21 |     {
22 |         $p = new ReflectionProperty(mysqli_sql_exception::class, 'sqlstate');
23 | 
24 |         return new self($exception->getMessage(), $p->getValue($exception), $exception->getCode(), $exception);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Initializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli;
 6 | 
 7 | use Doctrine\DBAL\Driver\Exception;
 8 | use mysqli;
 9 | 
10 | interface Initializer
11 | {
12 |     /** @throws Exception */
13 |     public function initialize(mysqli $connection): void;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Initializer/Charset.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Initializer;
 6 | 
 7 | use Doctrine\DBAL\Driver\Mysqli\Exception\InvalidCharset;
 8 | use Doctrine\DBAL\Driver\Mysqli\Initializer;
 9 | use mysqli;
10 | use mysqli_sql_exception;
11 | 
12 | final class Charset implements Initializer
13 | {
14 |     public function __construct(private readonly string $charset)
15 |     {
16 |     }
17 | 
18 |     public function initialize(mysqli $connection): void
19 |     {
20 |         try {
21 |             $success = $connection->set_charset($this->charset);
22 |         } catch (mysqli_sql_exception $e) {
23 |             throw InvalidCharset::upcast($e, $this->charset);
24 |         }
25 | 
26 |         if ($success) {
27 |             return;
28 |         }
29 | 
30 |         throw InvalidCharset::fromCharset($connection, $this->charset);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Initializer/Options.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Initializer;
 6 | 
 7 | use Doctrine\DBAL\Driver\Mysqli\Exception\InvalidOption;
 8 | use Doctrine\DBAL\Driver\Mysqli\Initializer;
 9 | use mysqli;
10 | 
11 | use function mysqli_options;
12 | 
13 | final class Options implements Initializer
14 | {
15 |     /** @param array<int,mixed> $options */
16 |     public function __construct(private readonly array $options)
17 |     {
18 |     }
19 | 
20 |     public function initialize(mysqli $connection): void
21 |     {
22 |         foreach ($this->options as $option => $value) {
23 |             if (! mysqli_options($connection, $option, $value)) {
24 |                 throw InvalidOption::fromOption($option, $value);
25 |             }
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Driver/Mysqli/Initializer/Secure.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\Mysqli\Initializer;
 6 | 
 7 | use Doctrine\DBAL\Driver\Mysqli\Initializer;
 8 | use mysqli;
 9 | use SensitiveParameter;
10 | 
11 | final class Secure implements Initializer
12 | {
13 |     public function __construct(
14 |         #[SensitiveParameter]
15 |         private readonly string $key,
16 |         private readonly string $cert,
17 |         private readonly string $ca,
18 |         private readonly string $capath,
19 |         private readonly string $cipher,
20 |     ) {
21 |     }
22 | 
23 |     public function initialize(mysqli $connection): void
24 |     {
25 |         $connection->ssl_set($this->key, $this->cert, $this->ca, $this->capath, $this->cipher);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Driver/OCI8/ConvertPositionalToNamedPlaceholders.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\OCI8;
 6 | 
 7 | use Doctrine\DBAL\SQL\Parser\Visitor;
 8 | 
 9 | use function count;
10 | use function implode;
11 | 
12 | /**
13 |  * Converts positional (?) into named placeholders (:param<num>).
14 |  *
15 |  * Oracle does not support positional parameters, hence this method converts all
16 |  * positional parameters into artificially named parameters.
17 |  *
18 |  * @internal This class is not covered by the backward compatibility promise
19 |  */
20 | final class ConvertPositionalToNamedPlaceholders implements Visitor
21 | {
22 |     /** @var list<string> */
23 |     private array $buffer = [];
24 | 
25 |     /** @var array<int,string> */
26 |     private array $parameterMap = [];
27 | 
28 |     public function acceptOther(string $sql): void
29 |     {
30 |         $this->buffer[] = $sql;
31 |     }
32 | 
33 |     public function acceptPositionalParameter(string $sql): void
34 |     {
35 |         $position = count($this->parameterMap) + 1;
36 |         $param    = ':param' . $position;
37 | 
38 |         $this->parameterMap[$position] = $param;
39 | 
40 |         $this->buffer[] = $param;
41 |     }
42 | 
43 |     public function acceptNamedParameter(string $sql): void
44 |     {
45 |         $this->buffer[] = $sql;
46 |     }
47 | 
48 |     public function getSQL(): string
49 |     {
50 |         return implode('', $this->buffer);
51 |     }
52 | 
53 |     /** @return array<int,string> */
54 |     public function getParameterMap(): array
55 |     {
56 |         return $this->parameterMap;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Driver/OCI8/Driver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\OCI8;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractOracleDriver;
 8 | use Doctrine\DBAL\Driver\OCI8\Exception\ConnectionFailed;
 9 | use Doctrine\DBAL\Driver\OCI8\Exception\InvalidConfiguration;
10 | use SensitiveParameter;
11 | 
12 | use function oci_connect;
13 | use function oci_new_connect;
14 | use function oci_pconnect;
15 | 
16 | use const OCI_NO_AUTO_COMMIT;
17 | 
18 | /**
19 |  * A Doctrine DBAL driver for the Oracle OCI8 PHP extensions.
20 |  */
21 | final class Driver extends AbstractOracleDriver
22 | {
23 |     /**
24 |      * {@inheritDoc}
25 |      */
26 |     public function connect(
27 |         #[SensitiveParameter]
28 |         array $params,
29 |     ): Connection {
30 |         $username    = $params['user'] ?? '';
31 |         $password    = $params['password'] ?? '';
32 |         $charset     = $params['charset'] ?? '';
33 |         $sessionMode = $params['sessionMode'] ?? OCI_NO_AUTO_COMMIT;
34 | 
35 |         $connectionString = $this->getEasyConnectString($params);
36 | 
37 |         $persistent = ! empty($params['persistent']);
38 |         $exclusive  = ! empty($params['driverOptions']['exclusive']);
39 | 
40 |         if ($persistent && $exclusive) {
41 |             throw InvalidConfiguration::forPersistentAndExclusive();
42 |         }
43 | 
44 |         if ($persistent) {
45 |             $connection = @oci_pconnect($username, $password, $connectionString, $charset, $sessionMode);
46 |         } elseif ($exclusive) {
47 |             $connection = @oci_new_connect($username, $password, $connectionString, $charset, $sessionMode);
48 |         } else {
49 |             $connection = @oci_connect($username, $password, $connectionString, $charset, $sessionMode);
50 |         }
51 | 
52 |         if ($connection === false) {
53 |             throw ConnectionFailed::new();
54 |         }
55 | 
56 |         return new Connection($connection);
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Driver/OCI8/Exception/ConnectionFailed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\OCI8\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function assert;
10 | use function oci_error;
11 | 
12 | /** @internal */
13 | final class ConnectionFailed extends AbstractException
14 | {
15 |     public static function new(): self
16 |     {
17 |         $error = oci_error();
18 |         assert($error !== false);
19 | 
20 |         return new self($error['message'], null, $error['code']);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Driver/OCI8/Exception/Error.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\OCI8\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function assert;
10 | use function oci_error;
11 | 
12 | /** @internal */
13 | final class Error extends AbstractException
14 | {
15 |     /** @param resource $resource */
16 |     public static function new($resource): self
17 |     {
18 |         $error = oci_error($resource);
19 |         assert($error !== false);
20 | 
21 |         return new self($error['message'], null, $error['code']);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Driver/OCI8/Exception/InvalidConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\OCI8\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | /** @internal */
10 | final class InvalidConfiguration extends AbstractException
11 | {
12 |     public static function forPersistentAndExclusive(): self
13 |     {
14 |         return new self('The "persistent" parameter and the "exclusive" driver option are mutually exclusive');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Driver/OCI8/Exception/NonTerminatedStringLiteral.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\OCI8\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function sprintf;
10 | 
11 | /** @internal */
12 | final class NonTerminatedStringLiteral extends AbstractException
13 | {
14 |     public static function new(int $offset): self
15 |     {
16 |         return new self(
17 |             sprintf(
18 |                 'The statement contains non-terminated string literal starting at offset %d.',
19 |                 $offset,
20 |             ),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Driver/OCI8/Exception/UnknownParameterIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\OCI8\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function sprintf;
10 | 
11 | /** @internal */
12 | final class UnknownParameterIndex extends AbstractException
13 | {
14 |     public static function new(int $index): self
15 |     {
16 |         return new self(
17 |             sprintf('Could not find variable mapping with index %d, in the SQL statement', $index),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Driver/OCI8/ExecutionMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\OCI8;
 6 | 
 7 | /**
 8 |  * Encapsulates the execution mode that is shared between the connection and its statements.
 9 |  *
10 |  * @internal This class is not covered by the backward compatibility promise
11 |  */
12 | final class ExecutionMode
13 | {
14 |     private bool $isAutoCommitEnabled = true;
15 | 
16 |     public function enableAutoCommit(): void
17 |     {
18 |         $this->isAutoCommitEnabled = true;
19 |     }
20 | 
21 |     public function disableAutoCommit(): void
22 |     {
23 |         $this->isAutoCommitEnabled = false;
24 |     }
25 | 
26 |     public function isAutoCommitEnabled(): bool
27 |     {
28 |         return $this->isAutoCommitEnabled;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Driver/OCI8/Middleware/InitializeSession.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\OCI8\Middleware;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | use Doctrine\DBAL\Driver\Connection;
 9 | use Doctrine\DBAL\Driver\Middleware;
10 | use Doctrine\DBAL\Driver\Middleware\AbstractDriverMiddleware;
11 | use SensitiveParameter;
12 | 
13 | final class InitializeSession implements Middleware
14 | {
15 |     public function wrap(Driver $driver): Driver
16 |     {
17 |         return new class ($driver) extends AbstractDriverMiddleware {
18 |             /**
19 |              * {@inheritDoc}
20 |              */
21 |             public function connect(
22 |                 #[SensitiveParameter]
23 |                 array $params,
24 |             ): Connection {
25 |                 $connection = parent::connect($params);
26 | 
27 |                 $connection->exec(
28 |                     'ALTER SESSION SET'
29 |                         . " NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'"
30 |                         . " NLS_TIME_FORMAT = 'HH24:MI:SS'"
31 |                         . " NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS'"
32 |                         . " NLS_TIMESTAMP_TZ_FORMAT = 'YYYY-MM-DD HH24:MI:SS TZH:TZM'"
33 |                         . " NLS_NUMERIC_CHARACTERS = '.,'",
34 |                 );
35 | 
36 |                 return $connection;
37 |             }
38 |         };
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Driver/PDO/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PDO;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | use PDOException;
 9 | 
10 | /** @internal */
11 | final class Exception extends AbstractException
12 | {
13 |     public static function new(PDOException $exception): self
14 |     {
15 |         if ($exception->errorInfo !== null) {
16 |             [$sqlState, $code] = $exception->errorInfo;
17 | 
18 |             $code ??= 0;
19 |         } else {
20 |             $code     = $exception->getCode();
21 |             $sqlState = null;
22 |         }
23 | 
24 |         return new self($exception->getMessage(), $sqlState, $code, $exception);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Driver/PDO/Exception/InvalidConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PDO\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function get_debug_type;
10 | use function sprintf;
11 | 
12 | final class InvalidConfiguration extends AbstractException
13 | {
14 |     public static function notAStringOrNull(string $key, mixed $value): self
15 |     {
16 |         return new self(sprintf(
17 |             'The %s configuration parameter is expected to be either a string or null, got %s.',
18 |             $key,
19 |             get_debug_type($value),
20 |         ));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Driver/PDO/OCI/Driver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PDO\OCI;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractOracleDriver;
 8 | use Doctrine\DBAL\Driver\PDO\Connection;
 9 | use Doctrine\DBAL\Driver\PDO\Exception;
10 | use Doctrine\DBAL\Driver\PDO\Exception\InvalidConfiguration;
11 | use Doctrine\DBAL\Driver\PDO\PDOConnect;
12 | use PDO;
13 | use PDOException;
14 | use SensitiveParameter;
15 | 
16 | use function is_string;
17 | 
18 | final class Driver extends AbstractOracleDriver
19 | {
20 |     use PDOConnect;
21 | 
22 |     /**
23 |      * {@inheritDoc}
24 |      */
25 |     public function connect(
26 |         #[SensitiveParameter]
27 |         array $params,
28 |     ): Connection {
29 |         $driverOptions = $params['driverOptions'] ?? [];
30 | 
31 |         if (! empty($params['persistent'])) {
32 |             $driverOptions[PDO::ATTR_PERSISTENT] = true;
33 |         }
34 | 
35 |         foreach (['user', 'password'] as $key) {
36 |             if (isset($params[$key]) && ! is_string($params[$key])) {
37 |                 throw InvalidConfiguration::notAStringOrNull($key, $params[$key]);
38 |             }
39 |         }
40 | 
41 |         $safeParams = $params;
42 |         unset($safeParams['password']);
43 | 
44 |         try {
45 |             $pdo = $this->doConnect(
46 |                 $this->constructPdoDsn($params),
47 |                 $params['user'] ?? '',
48 |                 $params['password'] ?? '',
49 |                 $driverOptions,
50 |             );
51 |         } catch (PDOException $exception) {
52 |             throw Exception::new($exception);
53 |         }
54 | 
55 |         return new Connection($pdo);
56 |     }
57 | 
58 |     /**
59 |      * Constructs the Oracle PDO DSN.
60 |      *
61 |      * @param mixed[] $params
62 |      */
63 |     private function constructPdoDsn(array $params): string
64 |     {
65 |         $dsn = 'oci:dbname=' . $this->getEasyConnectString($params);
66 | 
67 |         if (isset($params['charset'])) {
68 |             $dsn .= ';charset=' . $params['charset'];
69 |         }
70 | 
71 |         return $dsn;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Driver/PDO/PDOConnect.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PDO;
 6 | 
 7 | use PDO;
 8 | 
 9 | use const PHP_VERSION_ID;
10 | 
11 | /** @internal */
12 | trait PDOConnect
13 | {
14 |     /** @param array<int, mixed> $options */
15 |     private function doConnect(
16 |         string $dsn,
17 |         string $username,
18 |         string $password,
19 |         array $options,
20 |     ): PDO {
21 |         if (PHP_VERSION_ID < 80400) {
22 |             return new PDO($dsn, $username, $password, $options);
23 |         }
24 | 
25 |         return PDO::connect($dsn, $username, $password, $options);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Driver/PDO/SQLSrv/Connection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PDO\SQLSrv;
 6 | 
 7 | use Doctrine\DBAL\Driver\Middleware\AbstractConnectionMiddleware;
 8 | use Doctrine\DBAL\Driver\PDO\Connection as PDOConnection;
 9 | use PDO;
10 | 
11 | final class Connection extends AbstractConnectionMiddleware
12 | {
13 |     public function __construct(private readonly PDOConnection $connection)
14 |     {
15 |         parent::__construct($connection);
16 |     }
17 | 
18 |     public function prepare(string $sql): Statement
19 |     {
20 |         return new Statement(
21 |             $this->connection->prepare($sql),
22 |         );
23 |     }
24 | 
25 |     public function getNativeConnection(): PDO
26 |     {
27 |         return $this->connection->getNativeConnection();
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Driver/PDO/SQLSrv/Statement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PDO\SQLSrv;
 6 | 
 7 | use Doctrine\DBAL\Driver\Middleware\AbstractStatementMiddleware;
 8 | use Doctrine\DBAL\Driver\PDO\Statement as PDOStatement;
 9 | use Doctrine\DBAL\ParameterType;
10 | use PDO;
11 | 
12 | final class Statement extends AbstractStatementMiddleware
13 | {
14 |     /** @internal The statement can be only instantiated by its driver connection. */
15 |     public function __construct(private readonly PDOStatement $statement)
16 |     {
17 |         parent::__construct($statement);
18 |     }
19 | 
20 |     public function bindValue(int|string $param, mixed $value, ParameterType $type): void
21 |     {
22 |         switch ($type) {
23 |             case ParameterType::LARGE_OBJECT:
24 |             case ParameterType::BINARY:
25 |                 $this->statement->bindParamWithDriverOptions(
26 |                     $param,
27 |                     $value,
28 |                     $type,
29 |                     PDO::SQLSRV_ENCODING_BINARY,
30 |                 );
31 |                 break;
32 | 
33 |             case ParameterType::ASCII:
34 |                 $this->statement->bindParamWithDriverOptions(
35 |                     $param,
36 |                     $value,
37 |                     ParameterType::STRING,
38 |                     PDO::SQLSRV_ENCODING_SYSTEM,
39 |                 );
40 |                 break;
41 | 
42 |             default:
43 |                 $this->statement->bindValue($param, $value, $type);
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Driver/PDO/SQLite/Driver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PDO\SQLite;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractSQLiteDriver;
 8 | use Doctrine\DBAL\Driver\PDO\Connection;
 9 | use Doctrine\DBAL\Driver\PDO\Exception;
10 | use Doctrine\DBAL\Driver\PDO\Exception\InvalidConfiguration;
11 | use Doctrine\DBAL\Driver\PDO\PDOConnect;
12 | use PDOException;
13 | use SensitiveParameter;
14 | 
15 | use function array_intersect_key;
16 | use function is_string;
17 | 
18 | final class Driver extends AbstractSQLiteDriver
19 | {
20 |     use PDOConnect;
21 | 
22 |     /**
23 |      * {@inheritDoc}
24 |      */
25 |     public function connect(
26 |         #[SensitiveParameter]
27 |         array $params,
28 |     ): Connection {
29 |         foreach (['user', 'password'] as $key) {
30 |             if (isset($params[$key]) && ! is_string($params[$key])) {
31 |                 throw InvalidConfiguration::notAStringOrNull($key, $params[$key]);
32 |             }
33 |         }
34 | 
35 |         try {
36 |             $pdo = $this->doConnect(
37 |                 $this->constructPdoDsn(array_intersect_key($params, ['path' => true, 'memory' => true])),
38 |                 $params['user'] ?? '',
39 |                 $params['password'] ?? '',
40 |                 $params['driverOptions'] ?? [],
41 |             );
42 |         } catch (PDOException $exception) {
43 |             throw Exception::new($exception);
44 |         }
45 | 
46 |         return new Connection($pdo);
47 |     }
48 | 
49 |     /**
50 |      * Constructs the Sqlite PDO DSN.
51 |      *
52 |      * @param array<string, mixed> $params
53 |      */
54 |     private function constructPdoDsn(array $params): string
55 |     {
56 |         $dsn = 'sqlite:';
57 |         if (isset($params['path'])) {
58 |             $dsn .= $params['path'];
59 |         } elseif (isset($params['memory'])) {
60 |             $dsn .= ':memory:';
61 |         }
62 | 
63 |         return $dsn;
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Driver/PgSQL/ConvertParameters.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PgSQL;
 6 | 
 7 | use Doctrine\DBAL\SQL\Parser\Visitor;
 8 | 
 9 | use function count;
10 | use function implode;
11 | 
12 | final class ConvertParameters implements Visitor
13 | {
14 |     /** @var list<string> */
15 |     private array $buffer = [];
16 | 
17 |     /** @var array<array-key, int> */
18 |     private array $parameterMap = [];
19 | 
20 |     public function acceptPositionalParameter(string $sql): void
21 |     {
22 |         $position                      = count($this->parameterMap) + 1;
23 |         $this->parameterMap[$position] = $position;
24 |         $this->buffer[]                = '$' . $position;
25 |     }
26 | 
27 |     public function acceptNamedParameter(string $sql): void
28 |     {
29 |         $position                 = count($this->parameterMap) + 1;
30 |         $this->parameterMap[$sql] = $position;
31 |         $this->buffer[]           = '$' . $position;
32 |     }
33 | 
34 |     public function acceptOther(string $sql): void
35 |     {
36 |         $this->buffer[] = $sql;
37 |     }
38 | 
39 |     public function getSQL(): string
40 |     {
41 |         return implode('', $this->buffer);
42 |     }
43 | 
44 |     /** @return array<array-key, int> */
45 |     public function getParameterMap(): array
46 |     {
47 |         return $this->parameterMap;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Driver/PgSQL/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PgSQL;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | use PgSql\Result as PgSqlResult;
 9 | 
10 | use function pg_result_error_field;
11 | 
12 | use const PGSQL_DIAG_MESSAGE_PRIMARY;
13 | use const PGSQL_DIAG_SQLSTATE;
14 | 
15 | /** @internal */
16 | final class Exception extends AbstractException
17 | {
18 |     public static function fromResult(PgSqlResult $result): self
19 |     {
20 |         $sqlstate = pg_result_error_field($result, PGSQL_DIAG_SQLSTATE);
21 |         if ($sqlstate === false) {
22 |             $sqlstate = null;
23 |         }
24 | 
25 |         return new self((string) pg_result_error_field($result, PGSQL_DIAG_MESSAGE_PRIMARY), $sqlstate);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Driver/PgSQL/Exception/UnexpectedValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PgSQL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\Exception;
 8 | use UnexpectedValueException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class UnexpectedValue extends UnexpectedValueException implements Exception
13 | {
14 |     public static function new(string $value, string $type): self
15 |     {
16 |         return new self(sprintf(
17 |             'Unexpected value "%s" of type "%s" returned by Postgres',
18 |             $value,
19 |             $type,
20 |         ));
21 |     }
22 | 
23 |     /** @return null */
24 |     public function getSQLState(): string|null
25 |     {
26 |         return null;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Driver/PgSQL/Exception/UnknownParameter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\PgSQL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class UnknownParameter extends AbstractException
12 | {
13 |     public static function new(string $param): self
14 |     {
15 |         return new self(
16 |             sprintf('Could not find parameter %s in the SQL statement', $param),
17 |         );
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Driver/SQLSrv/Driver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\SQLSrv;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractSQLServerDriver;
 8 | use Doctrine\DBAL\Driver\AbstractSQLServerDriver\Exception\PortWithoutHost;
 9 | use Doctrine\DBAL\Driver\SQLSrv\Exception\Error;
10 | use SensitiveParameter;
11 | 
12 | use function sqlsrv_configure;
13 | use function sqlsrv_connect;
14 | 
15 | /**
16 |  * Driver for ext/sqlsrv.
17 |  */
18 | final class Driver extends AbstractSQLServerDriver
19 | {
20 |     /**
21 |      * {@inheritDoc}
22 |      */
23 |     public function connect(
24 |         #[SensitiveParameter]
25 |         array $params,
26 |     ): Connection {
27 |         $serverName = '';
28 | 
29 |         if (isset($params['host'])) {
30 |             $serverName = $params['host'];
31 | 
32 |             if (isset($params['port'])) {
33 |                 $serverName .= ',' . $params['port'];
34 |             }
35 |         } elseif (isset($params['port'])) {
36 |             throw PortWithoutHost::new();
37 |         }
38 | 
39 |         $driverOptions = $params['driverOptions'] ?? [];
40 | 
41 |         if (isset($params['dbname'])) {
42 |             $driverOptions['Database'] = $params['dbname'];
43 |         }
44 | 
45 |         if (isset($params['charset'])) {
46 |             $driverOptions['CharacterSet'] = $params['charset'];
47 |         }
48 | 
49 |         if (isset($params['user'])) {
50 |             $driverOptions['UID'] = $params['user'];
51 |         }
52 | 
53 |         if (isset($params['password'])) {
54 |             $driverOptions['PWD'] = $params['password'];
55 |         }
56 | 
57 |         if (! isset($driverOptions['ReturnDatesAsStrings'])) {
58 |             $driverOptions['ReturnDatesAsStrings'] = 1;
59 |         }
60 | 
61 |         if (! sqlsrv_configure('WarningsReturnAsErrors', 0)) {
62 |             throw Error::new();
63 |         }
64 | 
65 |         $connection = sqlsrv_connect($serverName, $driverOptions);
66 | 
67 |         if ($connection === false) {
68 |             throw Error::new();
69 |         }
70 | 
71 |         return new Connection($connection);
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Driver/SQLSrv/Exception/Error.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\SQLSrv\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | use function rtrim;
10 | use function sqlsrv_errors;
11 | 
12 | use const SQLSRV_ERR_ERRORS;
13 | 
14 | /** @internal */
15 | final class Error extends AbstractException
16 | {
17 |     public static function new(): self
18 |     {
19 |         $message  = '';
20 |         $sqlState = null;
21 |         $code     = 0;
22 | 
23 |         foreach ((array) sqlsrv_errors(SQLSRV_ERR_ERRORS) as $error) {
24 |             $message   .= 'SQLSTATE [' . $error['SQLSTATE'] . ', ' . $error['code'] . ']: ' . $error['message'] . "\n";
25 |             $sqlState ??= $error['SQLSTATE'];
26 | 
27 |             if ($code !== 0) {
28 |                 continue;
29 |             }
30 | 
31 |             $code = $error['code'];
32 |         }
33 | 
34 |         if ($message === '') {
35 |             $message = 'SQL Server error occurred but no error message was retrieved from driver.';
36 |         }
37 | 
38 |         return new self(rtrim($message), $sqlState, $code);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Driver/SQLite3/Driver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\SQLite3;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractSQLiteDriver;
 8 | use SensitiveParameter;
 9 | use SQLite3;
10 | 
11 | final class Driver extends AbstractSQLiteDriver
12 | {
13 |     /**
14 |      * {@inheritDoc}
15 |      */
16 |     public function connect(
17 |         #[SensitiveParameter]
18 |         array $params,
19 |     ): Connection {
20 |         $isMemory = $params['memory'] ?? false;
21 | 
22 |         if (isset($params['path'])) {
23 |             if ($isMemory) {
24 |                 throw new Exception(
25 |                     'Invalid connection settings: specifying both parameters "path" and "memory" is ambiguous.',
26 |                 );
27 |             }
28 | 
29 |             $filename = $params['path'];
30 |         } elseif ($isMemory) {
31 |             $filename = ':memory:';
32 |         } else {
33 |             throw new Exception(
34 |                 'Invalid connection settings: specify either the "path" or the "memory" parameter for SQLite3.',
35 |             );
36 |         }
37 | 
38 |         try {
39 |             $connection = new SQLite3($filename);
40 |         } catch (\Exception $e) {
41 |             throw Exception::new($e);
42 |         }
43 | 
44 |         $connection->enableExceptions(true);
45 | 
46 |         return new Connection($connection);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Driver/SQLite3/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\SQLite3;
 6 | 
 7 | use Doctrine\DBAL\Driver\AbstractException;
 8 | 
 9 | /** @internal */
10 | final class Exception extends AbstractException
11 | {
12 |     public static function new(\Exception $exception): self
13 |     {
14 |         return new self($exception->getMessage(), null, (int) $exception->getCode(), $exception);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Driver/SQLite3/Statement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver\SQLite3;
 6 | 
 7 | use Doctrine\DBAL\Driver\Statement as StatementInterface;
 8 | use Doctrine\DBAL\ParameterType;
 9 | use SQLite3;
10 | use SQLite3Stmt;
11 | 
12 | use function assert;
13 | 
14 | use const SQLITE3_BLOB;
15 | use const SQLITE3_INTEGER;
16 | use const SQLITE3_NULL;
17 | use const SQLITE3_TEXT;
18 | 
19 | final class Statement implements StatementInterface
20 | {
21 |     private const TYPE_BLOB    = SQLITE3_BLOB;
22 |     private const TYPE_INTEGER = SQLITE3_INTEGER;
23 |     private const TYPE_NULL    = SQLITE3_NULL;
24 |     private const TYPE_TEXT    = SQLITE3_TEXT;
25 | 
26 |     /** @internal The statement can be only instantiated by its driver connection. */
27 |     public function __construct(
28 |         private readonly SQLite3 $connection,
29 |         private readonly SQLite3Stmt $statement,
30 |     ) {
31 |     }
32 | 
33 |     public function bindValue(int|string $param, mixed $value, ParameterType $type): void
34 |     {
35 |         $this->statement->bindValue($param, $value, $this->convertParamType($type));
36 |     }
37 | 
38 |     public function execute(): Result
39 |     {
40 |         try {
41 |             $result = $this->statement->execute();
42 |         } catch (\Exception $e) {
43 |             throw Exception::new($e);
44 |         }
45 | 
46 |         assert($result !== false);
47 | 
48 |         return new Result($result, $this->connection->changes());
49 |     }
50 | 
51 |     /** @phpstan-return self::TYPE_* */
52 |     private function convertParamType(ParameterType $type): int
53 |     {
54 |         return match ($type) {
55 |             ParameterType::NULL => self::TYPE_NULL,
56 |             ParameterType::INTEGER, ParameterType::BOOLEAN => self::TYPE_INTEGER,
57 |             ParameterType::STRING, ParameterType::ASCII => self::TYPE_TEXT,
58 |             ParameterType::BINARY, ParameterType::LARGE_OBJECT => self::TYPE_BLOB,
59 |         };
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/Driver/Statement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Driver;
 6 | 
 7 | use Doctrine\DBAL\ParameterType;
 8 | 
 9 | /**
10 |  * Driver-level statement
11 |  */
12 | interface Statement
13 | {
14 |     /**
15 |      * Binds a value to a corresponding named (not supported by mysqli driver, see comment below) or positional
16 |      * placeholder in the SQL statement that was used to prepare the statement.
17 |      *
18 |      * As mentioned above, the named parameters are not natively supported by the mysqli driver, use executeQuery(),
19 |      * fetchAll(), fetchArray(), fetchColumn(), fetchAssoc() methods to have the named parameter emulated by doctrine.
20 |      *
21 |      * @param int|string    $param Parameter identifier. For a prepared statement using named placeholders,
22 |      *                             this will be a parameter name of the form :name. For a prepared statement
23 |      *                             using question mark placeholders, this will be the 1-indexed position
24 |      *                             of the parameter.
25 |      * @param mixed         $value The value to bind to the parameter.
26 |      * @param ParameterType $type  Explicit data type for the parameter using the {@see ParameterType}
27 |      *                             constants.
28 |      *
29 |      * @throws Exception
30 |      */
31 |     public function bindValue(int|string $param, mixed $value, ParameterType $type): void;
32 | 
33 |     /**
34 |      * Executes a prepared statement
35 |      *
36 |      * @throws Exception
37 |      */
38 |     public function execute(): Result;
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | use Throwable;
 8 | 
 9 | interface Exception extends Throwable
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Exception/CommitFailedRollbackOnly.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\ConnectionException;
 8 | 
 9 | final class CommitFailedRollbackOnly extends ConnectionException
10 | {
11 |     public static function new(): self
12 |     {
13 |         return new self('Transaction commit failed because the transaction has been marked for rollback only.');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/ConnectionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Base class for all connection related errors detected in the driver.
 9 |  */
10 | class ConnectionException extends DriverException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/ConnectionLost.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | final class ConnectionLost extends ConnectionException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/ConstraintViolationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Base class for all constraint violation related errors detected in the driver.
 9 |  */
10 | class ConstraintViolationException extends ServerException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/DatabaseDoesNotExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | class DatabaseDoesNotExist extends DatabaseObjectNotFoundException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/DatabaseObjectExistsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Base class for all already existing database object related errors detected in the driver.
 9 |  *
10 |  * A database object is considered any asset that can be created in a database
11 |  * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
12 |  * functions, stored procedures etc.
13 |  */
14 | class DatabaseObjectExistsException extends ServerException
15 | {
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Exception/DatabaseObjectNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Base class for all unknown database object related errors detected in the driver.
 9 |  *
10 |  * A database object is considered any asset that can be created in a database
11 |  * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
12 |  * functions, stored procedures etc.
13 |  */
14 | class DatabaseObjectNotFoundException extends ServerException
15 | {
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Exception/DatabaseRequired.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | 
 9 | use function sprintf;
10 | 
11 | class DatabaseRequired extends \Exception implements Exception
12 | {
13 |     public static function new(string $methodName): self
14 |     {
15 |         return new self(
16 |             sprintf(
17 |                 'A database is required for the method: %s.',
18 |                 $methodName,
19 |             ),
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Exception/DeadlockException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for a deadlock error of a transaction detected in the driver.
 9 |  */
10 | class DeadlockException extends ServerException implements RetryableException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/DriverException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | use Doctrine\DBAL\Exception;
 9 | use Doctrine\DBAL\Query;
10 | 
11 | use function assert;
12 | 
13 | /**
14 |  * Base class for all errors detected in the driver.
15 |  */
16 | class DriverException extends \Exception implements Exception, Driver\Exception
17 | {
18 |     /**
19 |      * @param Driver\Exception $driverException The DBAL driver exception to chain.
20 |      * @param Query|null       $query           The SQL query that triggered the exception, if any.
21 |      */
22 |     public function __construct(
23 |         Driver\Exception $driverException,
24 |         private readonly ?Query $query,
25 |     ) {
26 |         if ($query !== null) {
27 |             $message = 'An exception occurred while executing a query: ' . $driverException->getMessage();
28 |         } else {
29 |             $message = 'An exception occurred in the driver: ' . $driverException->getMessage();
30 |         }
31 | 
32 |         parent::__construct($message, $driverException->getCode(), $driverException);
33 |     }
34 | 
35 |     public function getSQLState(): ?string
36 |     {
37 |         $previous = $this->getPrevious();
38 |         assert($previous instanceof Driver\Exception);
39 | 
40 |         return $previous->getSQLState();
41 |     }
42 | 
43 |     public function getQuery(): ?Query
44 |     {
45 |         return $this->query;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Exception/DriverRequired.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | final class DriverRequired extends InvalidArgumentException
10 | {
11 |     /** @param string|null $url The URL that was provided in the connection parameters (if any). */
12 |     public static function new(?string $url = null): self
13 |     {
14 |         if ($url !== null) {
15 |             return new self(
16 |                 sprintf(
17 |                     'The options "driver" or "driverClass" are mandatory if a connection URL without scheme '
18 |                         . 'is given to DriverManager::getConnection(). Given URL "%s".',
19 |                     $url,
20 |                 ),
21 |             );
22 |         }
23 | 
24 |         return new self(
25 |             'The options "driver" or "driverClass" are mandatory if no PDO '
26 |                 . 'instance is given to DriverManager::getConnection().',
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Exception/ForeignKeyConstraintViolationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for a foreign key constraint violation detected in the driver.
 9 |  */
10 | class ForeignKeyConstraintViolationException extends ConstraintViolationException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidArgumentException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | 
 9 | /**
10 |  * Exception to be thrown when invalid arguments are passed to any DBAL API
11 |  */
12 | class InvalidArgumentException extends \InvalidArgumentException implements Exception
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidColumnDeclaration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class InvalidColumnDeclaration extends LogicException implements Exception
13 | {
14 |     public static function fromInvalidColumnType(string $columnName, InvalidColumnType $e): self
15 |     {
16 |         return new self(sprintf('Column "%s" has invalid type', $columnName), 0, $e);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidColumnIndex.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | use LogicException;
 9 | use Throwable;
10 | 
11 | use function sprintf;
12 | 
13 | final class InvalidColumnIndex extends LogicException implements Exception
14 | {
15 |     public static function new(int $index, ?Throwable $previous = null): self
16 |     {
17 |         return new self(sprintf('Invalid column index "%s".', $index), previous: $previous);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidColumnType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | use LogicException;
 9 | 
10 | abstract class InvalidColumnType extends LogicException implements Exception
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidColumnType/ColumnLengthRequired.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception\InvalidColumnType;
 6 | 
 7 | use Doctrine\DBAL\Exception\InvalidColumnType;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | 
10 | use function get_debug_type;
11 | use function sprintf;
12 | 
13 | /** @internal */
14 | final class ColumnLengthRequired extends InvalidColumnType
15 | {
16 |     /**
17 |      * @param AbstractPlatform $platform The target platform
18 |      * @param string           $type     The SQL column type
19 |      */
20 |     public static function new(AbstractPlatform $platform, string $type): self
21 |     {
22 |         return new self(
23 |             sprintf(
24 |                 '%s requires the length of a %s column to be specified',
25 |                 get_debug_type($platform),
26 |                 $type,
27 |             ),
28 |         );
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidColumnType/ColumnPrecisionRequired.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception\InvalidColumnType;
 6 | 
 7 | use Doctrine\DBAL\Exception\InvalidColumnType;
 8 | 
 9 | /** @internal */
10 | final class ColumnPrecisionRequired extends InvalidColumnType
11 | {
12 |     public static function new(): self
13 |     {
14 |         return new self('Column precision is not specified');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidColumnType/ColumnScaleRequired.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception\InvalidColumnType;
 6 | 
 7 | use Doctrine\DBAL\Exception\InvalidColumnType;
 8 | 
 9 | /** @internal */
10 | final class ColumnScaleRequired extends InvalidColumnType
11 | {
12 |     public static function new(): self
13 |     {
14 |         return new self('Column scale is not specified');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidColumnType/ColumnValuesRequired.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception\InvalidColumnType;
 6 | 
 7 | use Doctrine\DBAL\Exception\InvalidColumnType;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | 
10 | use function get_debug_type;
11 | use function sprintf;
12 | 
13 | final class ColumnValuesRequired extends InvalidColumnType
14 | {
15 |     /**
16 |      * @param AbstractPlatform $platform The target platform
17 |      * @param string           $type     The SQL column type
18 |      */
19 |     public static function new(AbstractPlatform $platform, string $type): self
20 |     {
21 |         return new self(
22 |             sprintf(
23 |                 '%s requires the values of a %s column to be specified',
24 |                 get_debug_type($platform),
25 |                 $type,
26 |             ),
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidDriverClass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Driver;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class InvalidDriverClass extends InvalidArgumentException
12 | {
13 |     public static function new(string $driverClass): self
14 |     {
15 |         return new self(
16 |             sprintf(
17 |                 'The given driver class %s has to implement the %s interface.',
18 |                 $driverClass,
19 |                 Driver::class,
20 |             ),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidFieldNameException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for an invalid specified field name in a statement detected in the driver.
 9 |  */
10 | class InvalidFieldNameException extends ServerException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidWrapperClass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class InvalidWrapperClass extends InvalidArgumentException
12 | {
13 |     public static function new(string $wrapperClass): self
14 |     {
15 |         return new self(
16 |             sprintf(
17 |                 'The given wrapper class %s has to be a subtype of %s.',
18 |                 $wrapperClass,
19 |                 Connection::class,
20 |             ),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exception/LockWaitTimeoutException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for a lock wait timeout error of a transaction detected in the driver.
 9 |  */
10 | class LockWaitTimeoutException extends ServerException implements RetryableException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/MalformedDsnException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | class MalformedDsnException extends InvalidArgumentException
 8 | {
 9 |     public static function new(): self
10 |     {
11 |         return new self('Malformed database connection URL');
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exception/NoActiveTransaction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\ConnectionException;
 8 | 
 9 | final class NoActiveTransaction extends ConnectionException
10 | {
11 |     public static function new(): self
12 |     {
13 |         return new self('There is no active transaction.');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/NoKeyValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | 
 9 | use function sprintf;
10 | 
11 | /** @internal */
12 | final class NoKeyValue extends \Exception implements Exception
13 | {
14 |     public static function fromColumnCount(int $columnCount): self
15 |     {
16 |         return new self(
17 |             sprintf(
18 |                 'Fetching as key-value pairs requires the result to contain at least 2 columns, %d given.',
19 |                 $columnCount,
20 |             ),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exception/NonUniqueFieldNameException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for a non-unique/ambiguous specified field name in a statement detected in the driver.
 9 |  */
10 | class NonUniqueFieldNameException extends ServerException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/NotNullConstraintViolationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for a NOT NULL constraint violation detected in the driver.
 9 |  */
10 | class NotNullConstraintViolationException extends ConstraintViolationException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/ReadOnlyException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for a write operation attempt on a read-only database element detected in the driver.
 9 |  */
10 | class ReadOnlyException extends ServerException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/RetryableException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | /**
10 |  * Marker interface for all exceptions where retrying the transaction makes sense.
11 |  */
12 | interface RetryableException extends Throwable
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/SavepointsNotSupported.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use Doctrine\DBAL\ConnectionException;
 8 | 
 9 | final class SavepointsNotSupported extends ConnectionException
10 | {
11 |     public static function new(): self
12 |     {
13 |         return new self('Savepoints are not supported by this driver.');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/SchemaDoesNotExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | class SchemaDoesNotExist extends DatabaseObjectNotFoundException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/ServerException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Base class for all server related errors detected in the driver.
 9 |  */
10 | class ServerException extends DriverException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/SyntaxErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for a syntax error in a statement detected in the driver.
 9 |  */
10 | class SyntaxErrorException extends ServerException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/TableExistsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for an already existing table referenced in a statement detected in the driver.
 9 |  */
10 | class TableExistsException extends DatabaseObjectExistsException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/TableNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for an unknown table referenced in a statement detected in the driver.
 9 |  */
10 | class TableNotFoundException extends DatabaseObjectNotFoundException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/TransactionRolledBack.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | class TransactionRolledBack extends DriverException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Exception/UniqueConstraintViolationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | /**
 8 |  * Exception for a unique constraint violation detected in the driver.
 9 |  */
10 | class UniqueConstraintViolationException extends ConstraintViolationException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exception/UnknownDriver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Exception;
 6 | 
 7 | use function implode;
 8 | use function sprintf;
 9 | 
10 | final class UnknownDriver extends InvalidArgumentException
11 | {
12 |     /** @param string[] $knownDrivers */
13 |     public static function new(string $unknownDriverName, array $knownDrivers): self
14 |     {
15 |         return new self(
16 |             sprintf(
17 |                 'The given driver "%s" is unknown, Doctrine currently supports only the following drivers: %s',
18 |                 $unknownDriverName,
19 |                 implode(', ', $knownDrivers),
20 |             ),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/LockMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | /**
 8 |  * Contains all supported lock modes.
 9 |  */
10 | enum LockMode
11 | {
12 |     case NONE;
13 |     case OPTIMISTIC;
14 |     case PESSIMISTIC_READ;
15 |     case PESSIMISTIC_WRITE;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Logging/Connection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Logging;
 6 | 
 7 | use Doctrine\DBAL\Driver\Connection as ConnectionInterface;
 8 | use Doctrine\DBAL\Driver\Middleware\AbstractConnectionMiddleware;
 9 | use Doctrine\DBAL\Driver\Result;
10 | use Doctrine\DBAL\Driver\Statement as DriverStatement;
11 | use Psr\Log\LoggerInterface;
12 | 
13 | final class Connection extends AbstractConnectionMiddleware
14 | {
15 |     /** @internal This connection can be only instantiated by its driver. */
16 |     public function __construct(ConnectionInterface $connection, private readonly LoggerInterface $logger)
17 |     {
18 |         parent::__construct($connection);
19 |     }
20 | 
21 |     public function __destruct()
22 |     {
23 |         $this->logger->info('Disconnecting');
24 |     }
25 | 
26 |     public function prepare(string $sql): DriverStatement
27 |     {
28 |         return new Statement(
29 |             parent::prepare($sql),
30 |             $this->logger,
31 |             $sql,
32 |         );
33 |     }
34 | 
35 |     public function query(string $sql): Result
36 |     {
37 |         $this->logger->debug('Executing query: {sql}', ['sql' => $sql]);
38 | 
39 |         return parent::query($sql);
40 |     }
41 | 
42 |     public function exec(string $sql): int|string
43 |     {
44 |         $this->logger->debug('Executing statement: {sql}', ['sql' => $sql]);
45 | 
46 |         return parent::exec($sql);
47 |     }
48 | 
49 |     public function beginTransaction(): void
50 |     {
51 |         $this->logger->debug('Beginning transaction');
52 | 
53 |         parent::beginTransaction();
54 |     }
55 | 
56 |     public function commit(): void
57 |     {
58 |         $this->logger->debug('Committing transaction');
59 | 
60 |         parent::commit();
61 |     }
62 | 
63 |     public function rollBack(): void
64 |     {
65 |         $this->logger->debug('Rolling back transaction');
66 | 
67 |         parent::rollBack();
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Logging/Driver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Logging;
 6 | 
 7 | use Doctrine\DBAL\Driver as DriverInterface;
 8 | use Doctrine\DBAL\Driver\Middleware\AbstractDriverMiddleware;
 9 | use Psr\Log\LoggerInterface;
10 | use SensitiveParameter;
11 | 
12 | final class Driver extends AbstractDriverMiddleware
13 | {
14 |     /** @internal This driver can be only instantiated by its middleware. */
15 |     public function __construct(DriverInterface $driver, private readonly LoggerInterface $logger)
16 |     {
17 |         parent::__construct($driver);
18 |     }
19 | 
20 |     /**
21 |      * {@inheritDoc}
22 |      */
23 |     public function connect(
24 |         #[SensitiveParameter]
25 |         array $params,
26 |     ): Connection {
27 |         $this->logger->info('Connecting with parameters {params}', ['params' => $this->maskPassword($params)]);
28 | 
29 |         return new Connection(
30 |             parent::connect($params),
31 |             $this->logger,
32 |         );
33 |     }
34 | 
35 |     /**
36 |      * @param array<string,mixed> $params Connection parameters
37 |      *
38 |      * @return array<string,mixed>
39 |      */
40 |     private function maskPassword(
41 |         #[SensitiveParameter]
42 |         array $params,
43 |     ): array {
44 |         if (isset($params['password'])) {
45 |             $params['password'] = '<redacted>';
46 |         }
47 | 
48 |         return $params;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Logging/Middleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Logging;
 6 | 
 7 | use Doctrine\DBAL\Driver as DriverInterface;
 8 | use Doctrine\DBAL\Driver\Middleware as MiddlewareInterface;
 9 | use Psr\Log\LoggerInterface;
10 | 
11 | final class Middleware implements MiddlewareInterface
12 | {
13 |     public function __construct(private readonly LoggerInterface $logger)
14 |     {
15 |     }
16 | 
17 |     public function wrap(DriverInterface $driver): DriverInterface
18 |     {
19 |         return new Driver($driver, $this->logger);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Logging/Statement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Logging;
 6 | 
 7 | use Doctrine\DBAL\Driver\Middleware\AbstractStatementMiddleware;
 8 | use Doctrine\DBAL\Driver\Result as ResultInterface;
 9 | use Doctrine\DBAL\Driver\Statement as StatementInterface;
10 | use Doctrine\DBAL\ParameterType;
11 | use Psr\Log\LoggerInterface;
12 | 
13 | final class Statement extends AbstractStatementMiddleware
14 | {
15 |     /** @var array<int,mixed>|array<string,mixed> */
16 |     private array $params = [];
17 | 
18 |     /** @var array<int,ParameterType>|array<string,ParameterType> */
19 |     private array $types = [];
20 | 
21 |     /** @internal This statement can be only instantiated by its connection. */
22 |     public function __construct(
23 |         StatementInterface $statement,
24 |         private readonly LoggerInterface $logger,
25 |         private readonly string $sql,
26 |     ) {
27 |         parent::__construct($statement);
28 |     }
29 | 
30 |     public function bindValue(int|string $param, mixed $value, ParameterType $type): void
31 |     {
32 |         $this->params[$param] = $value;
33 |         $this->types[$param]  = $type;
34 | 
35 |         parent::bindValue($param, $value, $type);
36 |     }
37 | 
38 |     public function execute(): ResultInterface
39 |     {
40 |         $this->logger->debug('Executing statement: {sql} (parameters: {params}, types: {types})', [
41 |             'sql'    => $this->sql,
42 |             'params' => $this->params,
43 |             'types'  => $this->types,
44 |         ]);
45 | 
46 |         return parent::execute();
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/ParameterType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | /**
 8 |  * Statement parameter type.
 9 |  */
10 | enum ParameterType
11 | {
12 |     /**
13 |      * Represents the SQL NULL data type.
14 |      */
15 |     case NULL;
16 | 
17 |     /**
18 |      * Represents the SQL INTEGER data type.
19 |      */
20 |     case INTEGER;
21 | 
22 |     /**
23 |      * Represents the SQL CHAR, VARCHAR, or other string data type.
24 |      */
25 |     case STRING;
26 | 
27 |     /**
28 |      * Represents the SQL large object data type.
29 |      */
30 |     case LARGE_OBJECT;
31 | 
32 |     /**
33 |      * Represents a boolean data type.
34 |      */
35 |     case BOOLEAN;
36 | 
37 |     /**
38 |      * Represents a binary string data type.
39 |      */
40 |     case BINARY;
41 | 
42 |     /**
43 |      * Represents an ASCII string data type
44 |      */
45 |     case ASCII;
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Platforms/DateIntervalUnit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms;
 6 | 
 7 | enum DateIntervalUnit: string
 8 | {
 9 |     case SECOND  = 'SECOND';
10 |     case MINUTE  = 'MINUTE';
11 |     case HOUR    = 'HOUR';
12 |     case DAY     = 'DAY';
13 |     case WEEK    = 'WEEK';
14 |     case MONTH   = 'MONTH';
15 |     case QUARTER = 'QUARTER';
16 |     case YEAR    = 'YEAR';
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Platforms/Exception/InvalidPlatformVersion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class InvalidPlatformVersion extends Exception implements PlatformException
12 | {
13 |     /**
14 |      * Returns a new instance for an invalid specified platform version.
15 |      *
16 |      * @param string $version        The invalid platform version given.
17 |      * @param string $expectedFormat The expected platform version format.
18 |      */
19 |     public static function new(string $version, string $expectedFormat): self
20 |     {
21 |         return new self(sprintf(
22 |             'Invalid platform version "%s" specified. The platform version has to be specified in the format: "%s".',
23 |             $version,
24 |             $expectedFormat,
25 |         ));
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Platforms/Exception/NoColumnsSpecifiedForTable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class NoColumnsSpecifiedForTable extends LogicException implements PlatformException
12 | {
13 |     public static function new(string $tableName): self
14 |     {
15 |         return new self(sprintf('No columns specified for table "%s".', $tableName));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Platforms/Exception/NotSupported.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\Exception;
 6 | 
 7 | use LogicException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class NotSupported extends LogicException implements PlatformException
12 | {
13 |     public static function new(string $method): self
14 |     {
15 |         return new self(sprintf('Operation "%s" is not supported by platform.', $method));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Platforms/Exception/PlatformException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\Exception;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | 
 9 | interface PlatformException extends Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Platforms/Keywords/KeywordList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\Keywords;
 6 | 
 7 | use function array_flip;
 8 | use function array_map;
 9 | use function strtoupper;
10 | 
11 | /**
12 |  * Abstract interface for a SQL reserved keyword dictionary.
13 |  */
14 | abstract class KeywordList
15 | {
16 |     /** @var string[]|null */
17 |     private ?array $keywords = null;
18 | 
19 |     /**
20 |      * Checks if the given word is a keyword of this dialect/vendor platform.
21 |      */
22 |     public function isKeyword(string $word): bool
23 |     {
24 |         if ($this->keywords === null) {
25 |             $this->initializeKeywords();
26 |         }
27 | 
28 |         return isset($this->keywords[strtoupper($word)]);
29 |     }
30 | 
31 |     protected function initializeKeywords(): void
32 |     {
33 |         $this->keywords = array_flip(array_map('strtoupper', $this->getKeywords()));
34 |     }
35 | 
36 |     /**
37 |      * Returns the list of keywords.
38 |      *
39 |      * @return string[]
40 |      */
41 |     abstract protected function getKeywords(): array;
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Platforms/Keywords/MySQL80Keywords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\Keywords;
 6 | 
 7 | use function array_merge;
 8 | 
 9 | /**
10 |  * MySQL 8.0 reserved keywords list.
11 |  *
12 |  * @deprecated This class will be removed once support for MySQL 5.7 is dropped.
13 |  */
14 | class MySQL80Keywords extends MySQLKeywords
15 | {
16 |     /**
17 |      * {@inheritDoc}
18 |      *
19 |      * @link https://dev.mysql.com/doc/refman/8.0/en/keywords.html
20 |      */
21 |     protected function getKeywords(): array
22 |     {
23 |         $keywords = parent::getKeywords();
24 | 
25 |         $keywords = array_merge($keywords, [
26 |             'ADMIN',
27 |             'ARRAY',
28 |             'CUBE',
29 |             'CUME_DIST',
30 |             'DENSE_RANK',
31 |             'EMPTY',
32 |             'EXCEPT',
33 |             'FIRST_VALUE',
34 |             'FUNCTION',
35 |             'GROUPING',
36 |             'GROUPS',
37 |             'JSON_TABLE',
38 |             'LAG',
39 |             'LAST_VALUE',
40 |             'LATERAL',
41 |             'LEAD',
42 |             'MEMBER',
43 |             'NTH_VALUE',
44 |             'NTILE',
45 |             'OF',
46 |             'OVER',
47 |             'PERCENT_RANK',
48 |             'PERSIST',
49 |             'PERSIST_ONLY',
50 |             'RANK',
51 |             'RECURSIVE',
52 |             'ROW',
53 |             'ROWS',
54 |             'ROW_NUMBER',
55 |             'SYSTEM',
56 |             'WINDOW',
57 |         ]);
58 | 
59 |         return $keywords;
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/Platforms/Keywords/MySQL84Keywords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\Keywords;
 6 | 
 7 | use function array_diff;
 8 | use function array_merge;
 9 | 
10 | /**
11 |  * MySQL 8.4 reserved keywords list.
12 |  */
13 | class MySQL84Keywords extends MySQL80Keywords
14 | {
15 |     /**
16 |      * {@inheritDoc}
17 |      *
18 |      * @link https://dev.mysql.com/doc/refman/8.4/en/keywords.html
19 |      */
20 |     protected function getKeywords(): array
21 |     {
22 |         $keywords = parent::getKeywords();
23 | 
24 |         // Removed Keywords and Reserved Words
25 |         $keywords = array_diff($keywords, [
26 |             'MASTER_BIND',
27 |             'MASTER_SSL_VERIFY_SERVER_CERT',
28 |         ]);
29 | 
30 |         // New Keywords and Reserved Words
31 |         $keywords = array_merge($keywords, [
32 |             'AUTO',
33 |             'BERNOULLI',
34 |             'GTIDS',
35 |             'LOG',
36 |             'MANUAL',
37 |             'PARALLEL',
38 |             'PARSE_TREE',
39 |             'QUALIFY',
40 |             'S3',
41 |             'TABLESAMPLE',
42 |         ]);
43 | 
44 |         return $keywords;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Platforms/MariaDB1010Platform.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms;
 6 | 
 7 | use Doctrine\DBAL\SQL\Builder\SelectSQLBuilder;
 8 | 
 9 | use function implode;
10 | 
11 | /**
12 |  * Provides the behavior, features and SQL dialect of the MariaDB 10.10 database platform.
13 |  */
14 | class MariaDB1010Platform extends MariaDB1060Platform
15 | {
16 |     public function createSelectSQLBuilder(): SelectSQLBuilder
17 |     {
18 |         return AbstractPlatform::createSelectSQLBuilder();
19 |     }
20 | 
21 |     public function fetchTableOptionsByTable(bool $includeTableName): string
22 |     {
23 |         // MariaDB-10.10.1 added FULL_COLLATION_NAME to the information_schema.COLLATION_CHARACTER_SET_APPLICABILITY.
24 |         // A base collation like uca1400_ai_ci can refer to multiple character sets. The value in the
25 |         // information_schema.TABLES.TABLE_COLLATION corresponds to the full collation name.
26 |         $sql = <<<'SQL'
27 |     SELECT t.TABLE_NAME,
28 |            t.ENGINE,
29 |            t.AUTO_INCREMENT,
30 |            t.TABLE_COMMENT,
31 |            t.CREATE_OPTIONS,
32 |            t.TABLE_COLLATION,
33 |            ccsa.CHARACTER_SET_NAME
34 |       FROM information_schema.TABLES t
35 |         INNER JOIN information_schema.COLLATION_CHARACTER_SET_APPLICABILITY ccsa
36 |           ON ccsa.FULL_COLLATION_NAME = t.TABLE_COLLATION
37 | SQL;
38 | 
39 |         $conditions = ['t.TABLE_SCHEMA = ?'];
40 | 
41 |         if ($includeTableName) {
42 |             $conditions[] = 't.TABLE_NAME = ?';
43 |         }
44 | 
45 |         $conditions[] = "t.TABLE_TYPE = 'BASE TABLE'";
46 | 
47 |         return $sql . ' WHERE ' . implode(' AND ', $conditions);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Platforms/MariaDB1052Platform.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms;
 6 | 
 7 | use Doctrine\DBAL\Schema\Index;
 8 | use Doctrine\DBAL\Schema\TableDiff;
 9 | 
10 | /**
11 |  * Provides the behavior, features and SQL dialect of the MariaDB 10.5 database platform.
12 |  *
13 |  * @deprecated This class will be removed once support for MariaDB 10.4 is dropped.
14 |  */
15 | class MariaDB1052Platform extends MariaDBPlatform
16 | {
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     protected function getPreAlterTableRenameIndexForeignKeySQL(TableDiff $diff): array
21 |     {
22 |         return AbstractMySQLPlatform::getPreAlterTableRenameIndexForeignKeySQL($diff);
23 |     }
24 | 
25 |     /**
26 |      * {@inheritDoc}
27 |      */
28 |     protected function getPostAlterTableIndexForeignKeySQL(TableDiff $diff): array
29 |     {
30 |         return AbstractMySQLPlatform::getPostAlterTableIndexForeignKeySQL($diff);
31 |     }
32 | 
33 |     /**
34 |      * {@inheritDoc}
35 |      */
36 |     protected function getRenameIndexSQL(string $oldIndexName, Index $index, $tableName): array
37 |     {
38 |         return ['ALTER TABLE ' . $tableName . ' RENAME INDEX ' . $oldIndexName . ' TO ' . $index->getQuotedName($this)];
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Platforms/MariaDB1060Platform.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms;
 6 | 
 7 | use Doctrine\DBAL\SQL\Builder\SelectSQLBuilder;
 8 | 
 9 | /**
10 |  * Provides the behavior, features and SQL dialect of the MariaDB 10.6 database platform.
11 |  */
12 | class MariaDB1060Platform extends MariaDB1052Platform
13 | {
14 |     public function createSelectSQLBuilder(): SelectSQLBuilder
15 |     {
16 |         return AbstractPlatform::createSelectSQLBuilder();
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQL/CharsetMetadataProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\MySQL;
 6 | 
 7 | /** @internal */
 8 | interface CharsetMetadataProvider
 9 | {
10 |     public function getDefaultCharsetCollation(string $charset): ?string;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQL/CharsetMetadataProvider/CachingCharsetMetadataProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\MySQL\CharsetMetadataProvider;
 6 | 
 7 | use Doctrine\DBAL\Platforms\MySQL\CharsetMetadataProvider;
 8 | 
 9 | use function array_key_exists;
10 | 
11 | /** @internal */
12 | final class CachingCharsetMetadataProvider implements CharsetMetadataProvider
13 | {
14 |     /** @var array<string,?string> */
15 |     private array $cache = [];
16 | 
17 |     public function __construct(private readonly CharsetMetadataProvider $charsetMetadataProvider)
18 |     {
19 |     }
20 | 
21 |     public function getDefaultCharsetCollation(string $charset): ?string
22 |     {
23 |         if (array_key_exists($charset, $this->cache)) {
24 |             return $this->cache[$charset];
25 |         }
26 | 
27 |         return $this->cache[$charset] = $this->charsetMetadataProvider->getDefaultCharsetCollation($charset);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQL/CharsetMetadataProvider/ConnectionCharsetMetadataProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\MySQL\CharsetMetadataProvider;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Exception;
 9 | use Doctrine\DBAL\Platforms\MySQL\CharsetMetadataProvider;
10 | 
11 | /** @internal */
12 | final class ConnectionCharsetMetadataProvider implements CharsetMetadataProvider
13 | {
14 |     public function __construct(private readonly Connection $connection)
15 |     {
16 |     }
17 | 
18 |     /** @throws Exception */
19 |     public function getDefaultCharsetCollation(string $charset): ?string
20 |     {
21 |         $collation = $this->connection->fetchOne(
22 |             <<<'SQL'
23 |             SELECT DEFAULT_COLLATE_NAME
24 |             FROM information_schema.CHARACTER_SETS
25 |             WHERE CHARACTER_SET_NAME = ?;
26 |             SQL
27 |             ,
28 |             [$charset],
29 |         );
30 | 
31 |         if ($collation !== false) {
32 |             return $collation;
33 |         }
34 | 
35 |         return null;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQL/CollationMetadataProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\MySQL;
 6 | 
 7 | /** @internal */
 8 | interface CollationMetadataProvider
 9 | {
10 |     public function getCollationCharset(string $collation): ?string;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQL/CollationMetadataProvider/CachingCollationMetadataProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\MySQL\CollationMetadataProvider;
 6 | 
 7 | use Doctrine\DBAL\Platforms\MySQL\CollationMetadataProvider;
 8 | 
 9 | use function array_key_exists;
10 | 
11 | /** @internal */
12 | final class CachingCollationMetadataProvider implements CollationMetadataProvider
13 | {
14 |     /** @var array<string,?string> */
15 |     private array $cache = [];
16 | 
17 |     public function __construct(private readonly CollationMetadataProvider $collationMetadataProvider)
18 |     {
19 |     }
20 | 
21 |     public function getCollationCharset(string $collation): ?string
22 |     {
23 |         if (array_key_exists($collation, $this->cache)) {
24 |             return $this->cache[$collation];
25 |         }
26 | 
27 |         return $this->cache[$collation] = $this->collationMetadataProvider->getCollationCharset($collation);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQL/CollationMetadataProvider/ConnectionCollationMetadataProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\MySQL\CollationMetadataProvider;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Exception;
 9 | use Doctrine\DBAL\Platforms\MySQL\CollationMetadataProvider;
10 | 
11 | /** @internal */
12 | final class ConnectionCollationMetadataProvider implements CollationMetadataProvider
13 | {
14 |     public function __construct(private readonly Connection $connection)
15 |     {
16 |     }
17 | 
18 |     /** @throws Exception */
19 |     public function getCollationCharset(string $collation): ?string
20 |     {
21 |         $charset = $this->connection->fetchOne(
22 |             <<<'SQL'
23 | SELECT CHARACTER_SET_NAME
24 | FROM information_schema.COLLATIONS
25 | WHERE COLLATION_NAME = ?;
26 | SQL
27 |             ,
28 |             [$collation],
29 |         );
30 | 
31 |         if ($charset !== false) {
32 |             return $charset;
33 |         }
34 | 
35 |         return null;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQL/DefaultTableOptions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\MySQL;
 6 | 
 7 | /** @internal */
 8 | final class DefaultTableOptions
 9 | {
10 |     public function __construct(private readonly string $charset, private readonly string $collation)
11 |     {
12 |     }
13 | 
14 |     public function getCharset(): string
15 |     {
16 |         return $this->charset;
17 |     }
18 | 
19 |     public function getCollation(): string
20 |     {
21 |         return $this->collation;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQL80Platform.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms;
 6 | 
 7 | use Doctrine\DBAL\Platforms\Keywords\KeywordList;
 8 | use Doctrine\DBAL\Platforms\Keywords\MySQL80Keywords;
 9 | use Doctrine\DBAL\SQL\Builder\SelectSQLBuilder;
10 | 
11 | /**
12 |  * Provides the behavior, features and SQL dialect of the MySQL 8.0 database platform.
13 |  *
14 |  * @deprecated This class will be removed once support for MySQL 5.7 is dropped.
15 |  */
16 | class MySQL80Platform extends MySQLPlatform
17 | {
18 |     protected function createReservedKeywordsList(): KeywordList
19 |     {
20 |         return new MySQL80Keywords();
21 |     }
22 | 
23 |     public function createSelectSQLBuilder(): SelectSQLBuilder
24 |     {
25 |         return AbstractPlatform::createSelectSQLBuilder();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQL84Platform.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms;
 6 | 
 7 | use Doctrine\DBAL\Platforms\Keywords\KeywordList;
 8 | use Doctrine\DBAL\Platforms\Keywords\MySQL84Keywords;
 9 | 
10 | /**
11 |  * Provides the behavior, features and SQL dialect of the MySQL 8.4 database platform.
12 |  */
13 | class MySQL84Platform extends MySQL80Platform
14 | {
15 |     protected function createReservedKeywordsList(): KeywordList
16 |     {
17 |         return new MySQL84Keywords();
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Platforms/MySQLPlatform.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms;
 6 | 
 7 | use Doctrine\DBAL\Platforms\Keywords\KeywordList;
 8 | use Doctrine\DBAL\Platforms\Keywords\MySQLKeywords;
 9 | use Doctrine\DBAL\Schema\Index;
10 | use Doctrine\DBAL\Types\BlobType;
11 | use Doctrine\DBAL\Types\TextType;
12 | 
13 | /**
14 |  * Provides the behavior, features and SQL dialect of the Oracle MySQL database platform
15 |  * of the oldest supported version.
16 |  */
17 | class MySQLPlatform extends AbstractMySQLPlatform
18 | {
19 |     /**
20 |      * {@inheritDoc}
21 |      *
22 |      * Oracle MySQL does not support default values on TEXT/BLOB columns until 8.0.13.
23 |      *
24 |      * @internal The method should be only used from within the {@see AbstractPlatform} class hierarchy.
25 |      *
26 |      * @link https://dev.mysql.com/doc/relnotes/mysql/8.0/en/news-8-0-13.html#mysqld-8-0-13-data-types
27 |      */
28 |     public function getDefaultValueDeclarationSQL(array $column): string
29 |     {
30 |         if ($column['type'] instanceof TextType || $column['type'] instanceof BlobType) {
31 |             unset($column['default']);
32 |         }
33 | 
34 |         return parent::getDefaultValueDeclarationSQL($column);
35 |     }
36 | 
37 |     /**
38 |      * {@inheritDoc}
39 |      */
40 |     protected function getRenameIndexSQL(string $oldIndexName, Index $index, string $tableName): array
41 |     {
42 |         return ['ALTER TABLE ' . $tableName . ' RENAME INDEX ' . $oldIndexName . ' TO ' . $index->getQuotedName($this)];
43 |     }
44 | 
45 |     protected function createReservedKeywordsList(): KeywordList
46 |     {
47 |         return new MySQLKeywords();
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Platforms/PostgreSQL120Platform.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms;
 6 | 
 7 | /**
 8 |  * Provides the behavior, features and SQL dialect of the PostgreSQL 12.0 database platform.
 9 |  *
10 |  * @deprecated This class will be removed once support for Postgres < 12 is dropped.
11 |  */
12 | class PostgreSQL120Platform extends PostgreSQLPlatform
13 | {
14 |     public function getDefaultColumnValueSQLSnippet(): string
15 |     {
16 |         // in case of GENERATED ALWAYS AS (foobar) STORED column (added in PostgreSQL 12.0)
17 |         // PostgreSQL's pg_get_expr(adbin, adrelid) will return the 'foobar' part
18 |         // which is not the 'default' value of the column but its 'definition'
19 |         // so in that case we force it to NULL as DBAL will use that column only for the
20 |         // 'default' value
21 |         return <<<'SQL'
22 |             SELECT
23 |                 CASE
24 |                     WHEN a.attgenerated = 's' THEN NULL
25 |                     ELSE pg_get_expr(adbin, adrelid)
26 |                 END
27 |              FROM pg_attrdef
28 |              WHERE c.oid = pg_attrdef.adrelid
29 |                 AND pg_attrdef.adnum=a.attnum
30 |         SQL;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Platforms/SQLServer/Comparator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\SQLServer;
 6 | 
 7 | use Doctrine\DBAL\Platforms\SQLServerPlatform;
 8 | use Doctrine\DBAL\Schema\Comparator as BaseComparator;
 9 | use Doctrine\DBAL\Schema\Table;
10 | use Doctrine\DBAL\Schema\TableDiff;
11 | 
12 | /**
13 |  * Compares schemas in the context of SQL Server platform.
14 |  *
15 |  * @link https://docs.microsoft.com/en-us/sql/t-sql/statements/collations?view=sql-server-ver15
16 |  */
17 | class Comparator extends BaseComparator
18 | {
19 |     /** @internal The comparator can be only instantiated by a schema manager. */
20 |     public function __construct(SQLServerPlatform $platform, private readonly string $databaseCollation)
21 |     {
22 |         parent::__construct($platform);
23 |     }
24 | 
25 |     public function compareTables(Table $oldTable, Table $newTable): TableDiff
26 |     {
27 |         return parent::compareTables(
28 |             $this->normalizeColumns($oldTable),
29 |             $this->normalizeColumns($newTable),
30 |         );
31 |     }
32 | 
33 |     private function normalizeColumns(Table $table): Table
34 |     {
35 |         $table = clone $table;
36 | 
37 |         foreach ($table->getColumns() as $column) {
38 |             $options = $column->getPlatformOptions();
39 | 
40 |             if (! isset($options['collation']) || $options['collation'] !== $this->databaseCollation) {
41 |                 continue;
42 |             }
43 | 
44 |             unset($options['collation']);
45 |             $column->setPlatformOptions($options);
46 |         }
47 | 
48 |         return $table;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Platforms/SQLite/Comparator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms\SQLite;
 6 | 
 7 | use Doctrine\DBAL\Platforms\SQLitePlatform;
 8 | use Doctrine\DBAL\Schema\Comparator as BaseComparator;
 9 | use Doctrine\DBAL\Schema\Table;
10 | use Doctrine\DBAL\Schema\TableDiff;
11 | 
12 | use function strcasecmp;
13 | 
14 | /**
15 |  * Compares schemas in the context of SQLite platform.
16 |  *
17 |  * BINARY is the default column collation and should be ignored if specified explicitly.
18 |  */
19 | class Comparator extends BaseComparator
20 | {
21 |     /** @internal The comparator can be only instantiated by a schema manager. */
22 |     public function __construct(SQLitePlatform $platform)
23 |     {
24 |         parent::__construct($platform);
25 |     }
26 | 
27 |     public function compareTables(Table $oldTable, Table $newTable): TableDiff
28 |     {
29 |         return parent::compareTables(
30 |             $this->normalizeColumns($oldTable),
31 |             $this->normalizeColumns($newTable),
32 |         );
33 |     }
34 | 
35 |     private function normalizeColumns(Table $table): Table
36 |     {
37 |         $table = clone $table;
38 | 
39 |         foreach ($table->getColumns() as $column) {
40 |             $options = $column->getPlatformOptions();
41 | 
42 |             if (! isset($options['collation']) || strcasecmp($options['collation'], 'binary') !== 0) {
43 |                 continue;
44 |             }
45 | 
46 |             unset($options['collation']);
47 |             $column->setPlatformOptions($options);
48 |         }
49 | 
50 |         return $table;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Platforms/TrimMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Platforms;
 6 | 
 7 | enum TrimMode
 8 | {
 9 |     case UNSPECIFIED;
10 |     case LEADING;
11 |     case TRAILING;
12 |     case BOTH;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Portability/Connection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Portability;
 6 | 
 7 | use Doctrine\DBAL\Driver\Connection as ConnectionInterface;
 8 | use Doctrine\DBAL\Driver\Middleware\AbstractConnectionMiddleware;
 9 | 
10 | /**
11 |  * Portability wrapper for a Connection.
12 |  */
13 | final class Connection extends AbstractConnectionMiddleware
14 | {
15 |     public const PORTABILITY_ALL           = 255;
16 |     public const PORTABILITY_NONE          = 0;
17 |     public const PORTABILITY_RTRIM         = 1;
18 |     public const PORTABILITY_EMPTY_TO_NULL = 4;
19 |     public const PORTABILITY_FIX_CASE      = 8;
20 | 
21 |     public function __construct(ConnectionInterface $connection, private readonly Converter $converter)
22 |     {
23 |         parent::__construct($connection);
24 |     }
25 | 
26 |     public function prepare(string $sql): Statement
27 |     {
28 |         return new Statement(
29 |             parent::prepare($sql),
30 |             $this->converter,
31 |         );
32 |     }
33 | 
34 |     public function query(string $sql): Result
35 |     {
36 |         return new Result(
37 |             parent::query($sql),
38 |             $this->converter,
39 |         );
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Portability/Middleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Portability;
 6 | 
 7 | use Doctrine\DBAL\ColumnCase;
 8 | use Doctrine\DBAL\Driver as DriverInterface;
 9 | use Doctrine\DBAL\Driver\Middleware as MiddlewareInterface;
10 | 
11 | final class Middleware implements MiddlewareInterface
12 | {
13 |     public function __construct(private readonly int $mode, private readonly ?ColumnCase $case)
14 |     {
15 |     }
16 | 
17 |     public function wrap(DriverInterface $driver): DriverInterface
18 |     {
19 |         if ($this->mode !== 0) {
20 |             return new Driver($driver, $this->mode, $this->case);
21 |         }
22 | 
23 |         return $driver;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Portability/OptimizeFlags.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Portability;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Platforms\DB2Platform;
 9 | use Doctrine\DBAL\Platforms\OraclePlatform;
10 | use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
11 | use Doctrine\DBAL\Platforms\SQLitePlatform;
12 | use Doctrine\DBAL\Platforms\SQLServerPlatform;
13 | 
14 | final class OptimizeFlags
15 | {
16 |     /**
17 |      * Platform-specific portability flags that need to be excluded from the user-provided mode
18 |      * since the platform already operates in this mode to avoid unnecessary conversion overhead.
19 |      *
20 |      * @var array<class-string, int>
21 |      */
22 |     private static array $platforms = [
23 |         DB2Platform::class        => 0,
24 |         OraclePlatform::class     => Connection::PORTABILITY_EMPTY_TO_NULL,
25 |         PostgreSQLPlatform::class => 0,
26 |         SQLitePlatform::class     => 0,
27 |         SQLServerPlatform::class  => 0,
28 |     ];
29 | 
30 |     public function __invoke(AbstractPlatform $platform, int $flags): int
31 |     {
32 |         foreach (self::$platforms as $class => $mask) {
33 |             if ($platform instanceof $class) {
34 |                 $flags &= ~$mask;
35 | 
36 |                 break;
37 |             }
38 |         }
39 | 
40 |         return $flags;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Portability/Result.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Portability;
 6 | 
 7 | use Doctrine\DBAL\Driver\Middleware\AbstractResultMiddleware;
 8 | use Doctrine\DBAL\Driver\Result as ResultInterface;
 9 | 
10 | final class Result extends AbstractResultMiddleware
11 | {
12 |     /** @internal The result can be only instantiated by the portability connection or statement. */
13 |     public function __construct(ResultInterface $result, private readonly Converter $converter)
14 |     {
15 |         parent::__construct($result);
16 |     }
17 | 
18 |     public function fetchNumeric(): array|false
19 |     {
20 |         return $this->converter->convertNumeric(
21 |             parent::fetchNumeric(),
22 |         );
23 |     }
24 | 
25 |     public function fetchAssociative(): array|false
26 |     {
27 |         return $this->converter->convertAssociative(
28 |             parent::fetchAssociative(),
29 |         );
30 |     }
31 | 
32 |     public function fetchOne(): mixed
33 |     {
34 |         return $this->converter->convertOne(
35 |             parent::fetchOne(),
36 |         );
37 |     }
38 | 
39 |     /**
40 |      * {@inheritDoc}
41 |      */
42 |     public function fetchAllNumeric(): array
43 |     {
44 |         return $this->converter->convertAllNumeric(
45 |             parent::fetchAllNumeric(),
46 |         );
47 |     }
48 | 
49 |     /**
50 |      * {@inheritDoc}
51 |      */
52 |     public function fetchAllAssociative(): array
53 |     {
54 |         return $this->converter->convertAllAssociative(
55 |             parent::fetchAllAssociative(),
56 |         );
57 |     }
58 | 
59 |     /**
60 |      * {@inheritDoc}
61 |      */
62 |     public function fetchFirstColumn(): array
63 |     {
64 |         return $this->converter->convertFirstColumn(
65 |             parent::fetchFirstColumn(),
66 |         );
67 |     }
68 | 
69 |     public function getColumnName(int $index): string
70 |     {
71 |         return $this->converter->convertColumnName(
72 |             parent::getColumnName($index),
73 |         );
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/Portability/Statement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Portability;
 6 | 
 7 | use Doctrine\DBAL\Driver\Middleware\AbstractStatementMiddleware;
 8 | use Doctrine\DBAL\Driver\Result as ResultInterface;
 9 | use Doctrine\DBAL\Driver\Statement as DriverStatement;
10 | 
11 | /**
12 |  * Portability wrapper for a Statement.
13 |  */
14 | final class Statement extends AbstractStatementMiddleware
15 | {
16 |     /**
17 |      * Wraps <tt>Statement</tt> and applies portability measures.
18 |      */
19 |     public function __construct(DriverStatement $stmt, private readonly Converter $converter)
20 |     {
21 |         parent::__construct($stmt);
22 |     }
23 | 
24 |     public function execute(): ResultInterface
25 |     {
26 |         return new Result(
27 |             parent::execute(),
28 |             $this->converter,
29 |         );
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Query.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | /**
 8 |  * An SQL query together with its bound parameters.
 9 |  *
10 |  * @phpstan-import-type WrapperParameterType from Connection
11 |  */
12 | final class Query
13 | {
14 |     /**
15 |      * @param array<mixed> $params
16 |      * @phpstan-param array<WrapperParameterType> $types
17 |      */
18 |     public function __construct(
19 |         private readonly string $sql,
20 |         private readonly array $params,
21 |         private readonly array $types,
22 |     ) {
23 |     }
24 | 
25 |     public function getSQL(): string
26 |     {
27 |         return $this->sql;
28 |     }
29 | 
30 |     /** @return array<mixed> */
31 |     public function getParams(): array
32 |     {
33 |         return $this->params;
34 |     }
35 | 
36 |     /** @phpstan-return array<WrapperParameterType> */
37 |     public function getTypes(): array
38 |     {
39 |         return $this->types;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Query/Exception/NonUniqueAlias.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query\Exception;
 6 | 
 7 | use Doctrine\DBAL\Query\QueryException;
 8 | 
 9 | use function implode;
10 | use function sprintf;
11 | 
12 | final class NonUniqueAlias extends QueryException
13 | {
14 |     /** @param string[] $registeredAliases */
15 |     public static function new(string $alias, array $registeredAliases): self
16 |     {
17 |         return new self(
18 |             sprintf(
19 |                 'The given alias "%s" is not unique in FROM and JOIN clause table. '
20 |                     . 'The currently registered aliases are: %s.',
21 |                 $alias,
22 |                 implode(', ', $registeredAliases),
23 |             ),
24 |         );
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/Exception/UnknownAlias.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query\Exception;
 6 | 
 7 | use Doctrine\DBAL\Query\QueryException;
 8 | 
 9 | use function implode;
10 | use function sprintf;
11 | 
12 | final class UnknownAlias extends QueryException
13 | {
14 |     /** @param string[] $registeredAliases */
15 |     public static function new(string $alias, array $registeredAliases): self
16 |     {
17 |         return new self(
18 |             sprintf(
19 |                 'The given alias "%s" is not part of any FROM or JOIN clause table. '
20 |                     . 'The currently registered aliases are: %s.',
21 |                 $alias,
22 |                 implode(', ', $registeredAliases),
23 |             ),
24 |         );
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Query/ForUpdate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | use Doctrine\DBAL\Query\ForUpdate\ConflictResolutionMode;
 8 | 
 9 | /** @internal */
10 | final class ForUpdate
11 | {
12 |     public function __construct(
13 |         private readonly ConflictResolutionMode $conflictResolutionMode,
14 |     ) {
15 |     }
16 | 
17 |     public function getConflictResolutionMode(): ConflictResolutionMode
18 |     {
19 |         return $this->conflictResolutionMode;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Query/ForUpdate/ConflictResolutionMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query\ForUpdate;
 6 | 
 7 | enum ConflictResolutionMode
 8 | {
 9 |     /**
10 |      * Wait for the row to be unlocked
11 |      */
12 |     case ORDINARY;
13 | 
14 |     /**
15 |      * Skip the row if it is locked
16 |      */
17 |     case SKIP_LOCKED;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Query/From.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | /** @internal */
 8 | final class From
 9 | {
10 |     public function __construct(
11 |         public readonly string $table,
12 |         public readonly ?string $alias = null,
13 |     ) {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Query/Join.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | /** @internal */
 8 | final class Join
 9 | {
10 |     private function __construct(
11 |         public readonly string $type,
12 |         public readonly string $table,
13 |         public readonly string $alias,
14 |         public readonly ?string $condition,
15 |     ) {
16 |     }
17 | 
18 |     public static function inner(string $table, string $alias, ?string $condition): Join
19 |     {
20 |         return new self('INNER', $table, $alias, $condition);
21 |     }
22 | 
23 |     public static function left(string $table, string $alias, ?string $condition): Join
24 |     {
25 |         return new self('LEFT', $table, $alias, $condition);
26 |     }
27 | 
28 |     public static function right(string $table, string $alias, ?string $condition): Join
29 |     {
30 |         return new self('RIGHT', $table, $alias, $condition);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Query/Limit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | final class Limit
 8 | {
 9 |     public function __construct(
10 |         private readonly ?int $maxResults,
11 |         private readonly int $firstResult,
12 |     ) {
13 |     }
14 | 
15 |     public function isDefined(): bool
16 |     {
17 |         return $this->maxResults !== null || $this->firstResult !== 0;
18 |     }
19 | 
20 |     public function getMaxResults(): ?int
21 |     {
22 |         return $this->maxResults;
23 |     }
24 | 
25 |     public function getFirstResult(): int
26 |     {
27 |         return $this->firstResult;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Query/QueryException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | 
 9 | class QueryException extends \Exception implements Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Query/QueryType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | /** @internal */
 8 | enum QueryType
 9 | {
10 |     case SELECT;
11 |     case DELETE;
12 |     case UPDATE;
13 |     case INSERT;
14 |     case UNION;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Query/SelectQuery.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | final class SelectQuery
 8 | {
 9 |     /**
10 |      * @internal This class should be instantiated only by {@link QueryBuilder}.
11 |      *
12 |      * @param string[] $columns
13 |      * @param string[] $from
14 |      * @param string[] $groupBy
15 |      * @param string[] $orderBy
16 |      */
17 |     public function __construct(
18 |         private readonly bool $distinct,
19 |         private readonly array $columns,
20 |         private readonly array $from,
21 |         private readonly ?string $where,
22 |         private readonly array $groupBy,
23 |         private readonly ?string $having,
24 |         private readonly array $orderBy,
25 |         private readonly Limit $limit,
26 |         private readonly ?ForUpdate $forUpdate,
27 |     ) {
28 |     }
29 | 
30 |     public function isDistinct(): bool
31 |     {
32 |         return $this->distinct;
33 |     }
34 | 
35 |     /** @return string[] */
36 |     public function getColumns(): array
37 |     {
38 |         return $this->columns;
39 |     }
40 | 
41 |     /** @return string[] */
42 |     public function getFrom(): array
43 |     {
44 |         return $this->from;
45 |     }
46 | 
47 |     public function getWhere(): ?string
48 |     {
49 |         return $this->where;
50 |     }
51 | 
52 |     /** @return string[] */
53 |     public function getGroupBy(): array
54 |     {
55 |         return $this->groupBy;
56 |     }
57 | 
58 |     public function getHaving(): ?string
59 |     {
60 |         return $this->having;
61 |     }
62 | 
63 |     /** @return string[] */
64 |     public function getOrderBy(): array
65 |     {
66 |         return $this->orderBy;
67 |     }
68 | 
69 |     public function getLimit(): Limit
70 |     {
71 |         return $this->limit;
72 |     }
73 | 
74 |     public function getForUpdate(): ?ForUpdate
75 |     {
76 |         return $this->forUpdate;
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/src/Query/Union.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | /** @internal */
 8 | final class Union
 9 | {
10 |     public function __construct(
11 |         public readonly string|QueryBuilder $query,
12 |         public readonly ?UnionType $type = null,
13 |     ) {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Query/UnionQuery.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | final class UnionQuery
 8 | {
 9 |     /**
10 |      * @internal This class should be instantiated only by {@link QueryBuilder}.
11 |      *
12 |      * @param Union[]  $unionParts
13 |      * @param string[] $orderBy
14 |      */
15 |     public function __construct(
16 |         private readonly array $unionParts,
17 |         private readonly array $orderBy,
18 |         private readonly Limit $limit,
19 |     ) {
20 |     }
21 | 
22 |     /** @return Union[] */
23 |     public function getUnionParts(): array
24 |     {
25 |         return $this->unionParts;
26 |     }
27 | 
28 |     /** @return string[] */
29 |     public function getOrderBy(): array
30 |     {
31 |         return $this->orderBy;
32 |     }
33 | 
34 |     public function getLimit(): Limit
35 |     {
36 |         return $this->limit;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Query/UnionType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Query;
 6 | 
 7 | enum UnionType
 8 | {
 9 |     case ALL;
10 |     case DISTINCT;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/SQL/Builder/CreateSchemaObjectsSQLBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\SQL\Builder;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Schema\Schema;
 9 | use Doctrine\DBAL\Schema\Sequence;
10 | use Doctrine\DBAL\Schema\Table;
11 | 
12 | use function array_merge;
13 | 
14 | final class CreateSchemaObjectsSQLBuilder
15 | {
16 |     public function __construct(private readonly AbstractPlatform $platform)
17 |     {
18 |     }
19 | 
20 |     /** @return list<string> */
21 |     public function buildSQL(Schema $schema): array
22 |     {
23 |         return array_merge(
24 |             $this->buildNamespaceStatements($schema->getNamespaces()),
25 |             $this->buildSequenceStatements($schema->getSequences()),
26 |             $this->buildTableStatements($schema->getTables()),
27 |         );
28 |     }
29 | 
30 |     /**
31 |      * @param string[] $namespaces
32 |      *
33 |      * @return list<string>
34 |      */
35 |     private function buildNamespaceStatements(array $namespaces): array
36 |     {
37 |         $statements = [];
38 | 
39 |         if ($this->platform->supportsSchemas()) {
40 |             foreach ($namespaces as $namespace) {
41 |                 $statements[] = $this->platform->getCreateSchemaSQL($namespace);
42 |             }
43 |         }
44 | 
45 |         return $statements;
46 |     }
47 | 
48 |     /**
49 |      * @param Table[] $tables
50 |      *
51 |      * @return list<string>
52 |      */
53 |     private function buildTableStatements(array $tables): array
54 |     {
55 |         return $this->platform->getCreateTablesSQL($tables);
56 |     }
57 | 
58 |     /**
59 |      * @param Sequence[] $sequences
60 |      *
61 |      * @return list<string>
62 |      */
63 |     private function buildSequenceStatements(array $sequences): array
64 |     {
65 |         $statements = [];
66 | 
67 |         foreach ($sequences as $sequence) {
68 |             $statements[] = $this->platform->getCreateSequenceSQL($sequence);
69 |         }
70 | 
71 |         return $statements;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/SQL/Builder/DefaultUnionSQLBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\SQL\Builder;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Query\UnionQuery;
 9 | use Doctrine\DBAL\Query\UnionType;
10 | 
11 | use function count;
12 | use function implode;
13 | 
14 | final class DefaultUnionSQLBuilder implements UnionSQLBuilder
15 | {
16 |     public function __construct(
17 |         private readonly AbstractPlatform $platform,
18 |     ) {
19 |     }
20 | 
21 |     public function buildSQL(UnionQuery $query): string
22 |     {
23 |         $parts = [];
24 |         foreach ($query->getUnionParts() as $union) {
25 |             if ($union->type !== null) {
26 |                 $parts[] = $union->type === UnionType::ALL
27 |                     ? $this->platform->getUnionAllSQL()
28 |                     : $this->platform->getUnionDistinctSQL();
29 |             }
30 | 
31 |             $parts[] = $this->platform->getUnionSelectPartSQL((string) $union->query);
32 |         }
33 | 
34 |         $orderBy = $query->getOrderBy();
35 |         if (count($orderBy) > 0) {
36 |             $parts[] = 'ORDER BY ' . implode(', ', $orderBy);
37 |         }
38 | 
39 |         $sql   = implode(' ', $parts);
40 |         $limit = $query->getLimit();
41 | 
42 |         if ($limit->isDefined()) {
43 |             $sql = $this->platform->modifyLimitQuery($sql, $limit->getMaxResults(), $limit->getFirstResult());
44 |         }
45 | 
46 |         return $sql;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/SQL/Builder/DropSchemaObjectsSQLBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\SQL\Builder;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Schema\Schema;
 9 | use Doctrine\DBAL\Schema\Sequence;
10 | use Doctrine\DBAL\Schema\Table;
11 | 
12 | use function array_merge;
13 | 
14 | final class DropSchemaObjectsSQLBuilder
15 | {
16 |     public function __construct(private readonly AbstractPlatform $platform)
17 |     {
18 |     }
19 | 
20 |     /** @return list<string> */
21 |     public function buildSQL(Schema $schema): array
22 |     {
23 |         return array_merge(
24 |             $this->buildSequenceStatements($schema->getSequences()),
25 |             $this->buildTableStatements($schema->getTables()),
26 |         );
27 |     }
28 | 
29 |     /**
30 |      * @param list<Table> $tables
31 |      *
32 |      * @return list<string>
33 |      */
34 |     private function buildTableStatements(array $tables): array
35 |     {
36 |         return $this->platform->getDropTablesSQL($tables);
37 |     }
38 | 
39 |     /**
40 |      * @param list<Sequence> $sequences
41 |      *
42 |      * @return list<string>
43 |      */
44 |     private function buildSequenceStatements(array $sequences): array
45 |     {
46 |         $statements = [];
47 | 
48 |         foreach ($sequences as $sequence) {
49 |             $statements[] = $this->platform->getDropSequenceSQL($sequence->getQuotedName($this->platform));
50 |         }
51 | 
52 |         return $statements;
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/SQL/Builder/SelectSQLBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\SQL\Builder;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | use Doctrine\DBAL\Query\SelectQuery;
 9 | 
10 | interface SelectSQLBuilder
11 | {
12 |     /** @throws Exception */
13 |     public function buildSQL(SelectQuery $query): string;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/SQL/Builder/UnionSQLBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\SQL\Builder;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | use Doctrine\DBAL\Query\UnionQuery;
 9 | 
10 | interface UnionSQLBuilder
11 | {
12 |     /** @throws Exception */
13 |     public function buildSQL(UnionQuery $query): string;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/SQL/Parser/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\SQL\Parser;
 6 | 
 7 | use Throwable;
 8 | 
 9 | interface Exception extends Throwable
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/SQL/Parser/Exception/RegularExpressionError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\SQL\Parser\Exception;
 6 | 
 7 | use Doctrine\DBAL\SQL\Parser\Exception;
 8 | use RuntimeException;
 9 | 
10 | use function preg_last_error;
11 | use function preg_last_error_msg;
12 | 
13 | class RegularExpressionError extends RuntimeException implements Exception
14 | {
15 |     public static function new(): self
16 |     {
17 |         return new self(preg_last_error_msg(), preg_last_error());
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/SQL/Parser/Visitor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\SQL\Parser;
 6 | 
 7 | /**
 8 |  * SQL parser visitor
 9 |  *
10 |  * @internal
11 |  */
12 | interface Visitor
13 | {
14 |     /**
15 |      * Accepts an SQL fragment containing a positional parameter
16 |      */
17 |     public function acceptPositionalParameter(string $sql): void;
18 | 
19 |     /**
20 |      * Accepts an SQL fragment containing a named parameter
21 |      */
22 |     public function acceptNamedParameter(string $sql): void;
23 | 
24 |     /**
25 |      * Accepts other SQL fragments
26 |      */
27 |     public function acceptOther(string $sql): void;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Schema/DefaultSchemaManagerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Exception;
 9 | 
10 | /**
11 |  * A schema manager factory that returns the default schema manager for the given platform.
12 |  */
13 | final class DefaultSchemaManagerFactory implements SchemaManagerFactory
14 | {
15 |     /** @throws Exception If the platform does not support creating schema managers yet. */
16 |     public function createSchemaManager(Connection $connection): AbstractSchemaManager
17 |     {
18 |         return $connection->getDatabasePlatform()->createSchemaManager($connection);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/ColumnAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class ColumnAlreadyExists extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $tableName, string $columnName): self
15 |     {
16 |         return new self(sprintf('The column "%s" on table "%s" already exists.', $columnName, $tableName));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/ColumnDoesNotExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class ColumnDoesNotExist extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $columnName, string $table): self
15 |     {
16 |         return new self(sprintf('There is no column with name "%s" on table "%s".', $columnName, $table));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/ForeignKeyDoesNotExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class ForeignKeyDoesNotExist extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $foreignKeyName, string $table): self
15 |     {
16 |         return new self(
17 |             sprintf('There exists no foreign key with the name "%s" on table "%s".', $foreignKeyName, $table),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/IndexAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class IndexAlreadyExists extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $indexName, string $table): self
15 |     {
16 |         return new self(
17 |             sprintf('An index with name "%s" was already defined on table "%s".', $indexName, $table),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/IndexDoesNotExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class IndexDoesNotExist extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $indexName, string $table): self
15 |     {
16 |         return new self(sprintf('Index "%s" does not exist on table "%s".', $indexName, $table));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/IndexNameInvalid.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use InvalidArgumentException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class IndexNameInvalid extends InvalidArgumentException implements SchemaException
13 | {
14 |     public static function new(string $indexName): self
15 |     {
16 |         return new self(sprintf('Invalid index name "%s" given, has to be [a-zA-Z0-9_].', $indexName));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/InvalidTableName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use InvalidArgumentException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class InvalidTableName extends InvalidArgumentException implements SchemaException
13 | {
14 |     public static function new(string $tableName): self
15 |     {
16 |         return new self(sprintf('Invalid table name specified "%s".', $tableName));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/NamespaceAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class NamespaceAlreadyExists extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $namespaceName): self
15 |     {
16 |         return new self(sprintf('The namespace with name "%s" already exists.', $namespaceName));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/SequenceAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class SequenceAlreadyExists extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $sequenceName): self
15 |     {
16 |         return new self(sprintf('The sequence "%s" already exists.', $sequenceName));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/SequenceDoesNotExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class SequenceDoesNotExist extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $sequenceName): self
15 |     {
16 |         return new self(sprintf('There exists no sequence with the name "%s".', $sequenceName));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/TableAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class TableAlreadyExists extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $tableName): self
15 |     {
16 |         return new self(sprintf('The table with name "%s" already exists.', $tableName));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/TableDoesNotExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class TableDoesNotExist extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $tableName): self
15 |     {
16 |         return new self(sprintf('There is no table with name "%s" in the schema.', $tableName));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/UniqueConstraintDoesNotExist.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use LogicException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class UniqueConstraintDoesNotExist extends LogicException implements SchemaException
13 | {
14 |     public static function new(string $constraintName, string $table): self
15 |     {
16 |         return new self(
17 |             sprintf('There exists no unique constraint with the name "%s" on table "%s".', $constraintName, $table),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Schema/Exception/UnknownColumnOption.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema\Exception;
 6 | 
 7 | use Doctrine\DBAL\Schema\SchemaException;
 8 | use InvalidArgumentException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class UnknownColumnOption extends InvalidArgumentException implements SchemaException
13 | {
14 |     public static function new(string $name): self
15 |     {
16 |         return new self(
17 |             sprintf('The "%s" column option is not supported.', $name),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Schema/Identifier.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema;
 6 | 
 7 | /**
 8 |  * An abstraction class for an asset identifier.
 9 |  *
10 |  * Wraps identifier names like column names in indexes / foreign keys
11 |  * in an abstract class for proper quotation capabilities.
12 |  */
13 | class Identifier extends AbstractAsset
14 | {
15 |     /**
16 |      * @param string $identifier Identifier name to wrap.
17 |      * @param bool   $quote      Whether to force quoting the given identifier.
18 |      */
19 |     public function __construct(string $identifier, bool $quote = false)
20 |     {
21 |         $this->_setName($identifier);
22 | 
23 |         if (! $quote || $this->_quoted) {
24 |             return;
25 |         }
26 | 
27 |         $this->_setName('"' . $this->getName() . '"');
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Schema/SchemaConfig.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema;
 6 | 
 7 | /**
 8 |  * Configuration for a Schema.
 9 |  */
10 | class SchemaConfig
11 | {
12 |     protected int $maxIdentifierLength = 63;
13 | 
14 |     protected ?string $name = null;
15 | 
16 |     /** @var array<string, mixed> */
17 |     protected array $defaultTableOptions = [];
18 | 
19 |     public function setMaxIdentifierLength(int $length): void
20 |     {
21 |         $this->maxIdentifierLength = $length;
22 |     }
23 | 
24 |     public function getMaxIdentifierLength(): int
25 |     {
26 |         return $this->maxIdentifierLength;
27 |     }
28 | 
29 |     /**
30 |      * Gets the default namespace of schema objects.
31 |      */
32 |     public function getName(): ?string
33 |     {
34 |         return $this->name;
35 |     }
36 | 
37 |     /**
38 |      * Sets the default namespace name of schema objects.
39 |      */
40 |     public function setName(?string $name): void
41 |     {
42 |         $this->name = $name;
43 |     }
44 | 
45 |     /**
46 |      * Gets the default options that are passed to Table instances created with
47 |      * Schema#createTable().
48 |      *
49 |      * @return array<string, mixed>
50 |      */
51 |     public function getDefaultTableOptions(): array
52 |     {
53 |         return $this->defaultTableOptions;
54 |     }
55 | 
56 |     /** @param array<string, mixed> $defaultTableOptions */
57 |     public function setDefaultTableOptions(array $defaultTableOptions): void
58 |     {
59 |         $this->defaultTableOptions = $defaultTableOptions;
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/Schema/SchemaException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | 
 9 | interface SchemaException extends Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Schema/SchemaManagerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | 
 9 | /**
10 |  * Creates a schema manager for the given connection.
11 |  *
12 |  * This interface is an extension point for applications that need to override schema managers.
13 |  */
14 | interface SchemaManagerFactory
15 | {
16 |     public function createSchemaManager(Connection $connection): AbstractSchemaManager;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Schema/View.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Schema;
 6 | 
 7 | /**
 8 |  * Representation of a Database View.
 9 |  */
10 | class View extends AbstractAsset
11 | {
12 |     public function __construct(string $name, private readonly string $sql)
13 |     {
14 |         $this->_setName($name);
15 |     }
16 | 
17 |     public function getSql(): string
18 |     {
19 |         return $this->sql;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/ServerVersionProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | interface ServerVersionProvider
 8 | {
 9 |     /**
10 |      * Returns the database server version
11 |      */
12 |     public function getServerVersion(): string;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Tools/Console/ConnectionNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Tools\Console;
 6 | 
 7 | use OutOfBoundsException;
 8 | 
 9 | final class ConnectionNotFound extends OutOfBoundsException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Tools/Console/ConnectionProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Tools\Console;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | 
 9 | interface ConnectionProvider
10 | {
11 |     public function getDefaultConnection(): Connection;
12 | 
13 |     /** @throws ConnectionNotFound in case a connection with the given name does not exist. */
14 |     public function getConnection(string $name): Connection;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Tools/Console/ConnectionProvider/SingleConnectionProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Tools\Console\ConnectionProvider;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Tools\Console\ConnectionNotFound;
 9 | use Doctrine\DBAL\Tools\Console\ConnectionProvider;
10 | 
11 | use function sprintf;
12 | 
13 | class SingleConnectionProvider implements ConnectionProvider
14 | {
15 |     public function __construct(
16 |         private readonly Connection $connection,
17 |         private readonly string $defaultConnectionName = 'default',
18 |     ) {
19 |     }
20 | 
21 |     public function getDefaultConnection(): Connection
22 |     {
23 |         return $this->connection;
24 |     }
25 | 
26 |     public function getConnection(string $name): Connection
27 |     {
28 |         if ($name !== $this->defaultConnectionName) {
29 |             throw new ConnectionNotFound(sprintf('Connection with name "%s" does not exist.', $name));
30 |         }
31 | 
32 |         return $this->connection;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/TransactionIsolationLevel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL;
 6 | 
 7 | enum TransactionIsolationLevel
 8 | {
 9 |     case READ_UNCOMMITTED;
10 |     case READ_COMMITTED;
11 |     case REPEATABLE_READ;
12 |     case SERIALIZABLE;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Types/AsciiStringType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\ParameterType;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | 
10 | final class AsciiStringType extends StringType
11 | {
12 |     /**
13 |      * {@inheritDoc}
14 |      */
15 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
16 |     {
17 |         return $platform->getAsciiStringTypeDeclarationSQL($column);
18 |     }
19 | 
20 |     public function getBindingType(): ParameterType
21 |     {
22 |         return ParameterType::ASCII;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Types/BigIntType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\ParameterType;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | 
10 | use function assert;
11 | use function is_int;
12 | use function is_string;
13 | 
14 | use const PHP_INT_MAX;
15 | use const PHP_INT_MIN;
16 | 
17 | /**
18 |  * Type that attempts to map a database BIGINT to a PHP int.
19 |  *
20 |  * If the presented value is outside of PHP's integer range, the value is returned as-is (usually a string).
21 |  */
22 | class BigIntType extends Type implements PhpIntegerMappingType
23 | {
24 |     /**
25 |      * {@inheritDoc}
26 |      */
27 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
28 |     {
29 |         return $platform->getBigIntTypeDeclarationSQL($column);
30 |     }
31 | 
32 |     public function getBindingType(): ParameterType
33 |     {
34 |         return ParameterType::STRING;
35 |     }
36 | 
37 |     /**
38 |      * @param T $value
39 |      *
40 |      * @return (T is null ? null : int|string)
41 |      *
42 |      * @template T
43 |      */
44 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): int|string|null
45 |     {
46 |         if ($value === null || is_int($value)) {
47 |             return $value;
48 |         }
49 | 
50 |         assert(
51 |             is_string($value),
52 |             'DBAL assumes values outside of the integer range to be returned as string by the database driver.',
53 |         );
54 | 
55 |         if (
56 |             ($value > PHP_INT_MIN && $value < PHP_INT_MAX)
57 |             || $value === (string) (int) $value
58 |         ) {
59 |             return (int) $value;
60 |         }
61 | 
62 |         return $value;
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/Types/BinaryType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\ParameterType;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | use Doctrine\DBAL\Types\Exception\ValueNotConvertible;
10 | 
11 | use function is_resource;
12 | use function is_string;
13 | use function stream_get_contents;
14 | 
15 | /**
16 |  * Type that maps ab SQL BINARY/VARBINARY to a PHP resource stream.
17 |  */
18 | class BinaryType extends Type
19 | {
20 |     /**
21 |      * {@inheritDoc}
22 |      */
23 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
24 |     {
25 |         return $platform->getBinaryTypeDeclarationSQL($column);
26 |     }
27 | 
28 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?string
29 |     {
30 |         if ($value === null) {
31 |             return null;
32 |         }
33 | 
34 |         if (is_resource($value)) {
35 |             $value = stream_get_contents($value);
36 |         }
37 | 
38 |         if (! is_string($value)) {
39 |             throw ValueNotConvertible::new($value, Types::BINARY);
40 |         }
41 | 
42 |         return $value;
43 |     }
44 | 
45 |     public function getBindingType(): ParameterType
46 |     {
47 |         return ParameterType::BINARY;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Types/BlobType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\ParameterType;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | use Doctrine\DBAL\Types\Exception\ValueNotConvertible;
10 | 
11 | use function assert;
12 | use function fopen;
13 | use function fseek;
14 | use function fwrite;
15 | use function is_resource;
16 | use function is_string;
17 | 
18 | /**
19 |  * Type that maps an SQL BLOB to a PHP resource stream.
20 |  */
21 | class BlobType extends Type
22 | {
23 |     /**
24 |      * {@inheritDoc}
25 |      */
26 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
27 |     {
28 |         return $platform->getBlobTypeDeclarationSQL($column);
29 |     }
30 | 
31 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): mixed
32 |     {
33 |         if ($value === null) {
34 |             return null;
35 |         }
36 | 
37 |         if (is_string($value)) {
38 |             $fp = fopen('php://temp', 'rb+');
39 |             assert(is_resource($fp));
40 |             fwrite($fp, $value);
41 |             fseek($fp, 0);
42 |             $value = $fp;
43 |         }
44 | 
45 |         if (! is_resource($value)) {
46 |             throw ValueNotConvertible::new($value, Types::BLOB);
47 |         }
48 | 
49 |         return $value;
50 |     }
51 | 
52 |     public function getBindingType(): ParameterType
53 |     {
54 |         return ParameterType::LARGE_OBJECT;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Types/BooleanType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\ParameterType;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | 
10 | /**
11 |  * Type that maps an SQL boolean to a PHP boolean.
12 |  */
13 | class BooleanType extends Type
14 | {
15 |     /**
16 |      * {@inheritDoc}
17 |      */
18 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
19 |     {
20 |         return $platform->getBooleanTypeDeclarationSQL($column);
21 |     }
22 | 
23 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): mixed
24 |     {
25 |         return $platform->convertBooleansToDatabaseValue($value);
26 |     }
27 | 
28 |     /**
29 |      * @param T $value
30 |      *
31 |      * @return (T is null ? null : bool)
32 |      *
33 |      * @template T
34 |      */
35 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?bool
36 |     {
37 |         return $platform->convertFromBoolean($value);
38 |     }
39 | 
40 |     public function getBindingType(): ParameterType
41 |     {
42 |         return ParameterType::BOOLEAN;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Types/ConversionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | 
 9 | /**
10 |  * Conversion Exception is thrown when the database to PHP conversion fails.
11 |  */
12 | class ConversionException extends \Exception implements Exception
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Types/DateImmutableType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use DateTimeImmutable;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | use Doctrine\DBAL\Types\Exception\InvalidFormat;
10 | use Doctrine\DBAL\Types\Exception\InvalidType;
11 | 
12 | /**
13 |  * Immutable type of {@see DateType}.
14 |  */
15 | class DateImmutableType extends Type implements PhpDateMappingType
16 | {
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
21 |     {
22 |         return $platform->getDateTypeDeclarationSQL($column);
23 |     }
24 | 
25 |     /**
26 |      * @param T $value
27 |      *
28 |      * @return (T is null ? null : string)
29 |      *
30 |      * @template T
31 |      */
32 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): ?string
33 |     {
34 |         if ($value === null) {
35 |             return $value;
36 |         }
37 | 
38 |         if ($value instanceof DateTimeImmutable) {
39 |             return $value->format($platform->getDateFormatString());
40 |         }
41 | 
42 |         throw InvalidType::new(
43 |             $value,
44 |             static::class,
45 |             ['null', DateTimeImmutable::class],
46 |         );
47 |     }
48 | 
49 |     /**
50 |      * @param T $value
51 |      *
52 |      * @return (T is null ? null : DateTimeImmutable)
53 |      *
54 |      * @template T
55 |      */
56 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?DateTimeImmutable
57 |     {
58 |         if ($value === null || $value instanceof DateTimeImmutable) {
59 |             return $value;
60 |         }
61 | 
62 |         $dateTime = DateTimeImmutable::createFromFormat('!' . $platform->getDateFormatString(), $value);
63 | 
64 |         if ($dateTime === false) {
65 |             throw InvalidFormat::new(
66 |                 $value,
67 |                 static::class,
68 |                 $platform->getDateFormatString(),
69 |             );
70 |         }
71 | 
72 |         return $dateTime;
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/Types/DateType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use DateTime;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | use Doctrine\DBAL\Types\Exception\InvalidFormat;
10 | use Doctrine\DBAL\Types\Exception\InvalidType;
11 | 
12 | /**
13 |  * Type that maps an SQL DATE to a PHP Date object.
14 |  */
15 | class DateType extends Type implements PhpDateMappingType
16 | {
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
21 |     {
22 |         return $platform->getDateTypeDeclarationSQL($column);
23 |     }
24 | 
25 |     /**
26 |      * @phpstan-param T $value
27 |      *
28 |      * @return (T is null ? null : string)
29 |      *
30 |      * @template T
31 |      */
32 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): mixed
33 |     {
34 |         if ($value === null) {
35 |             return $value;
36 |         }
37 | 
38 |         if ($value instanceof DateTime) {
39 |             return $value->format($platform->getDateFormatString());
40 |         }
41 | 
42 |         throw InvalidType::new($value, static::class, ['null', DateTime::class]);
43 |     }
44 | 
45 |     /**
46 |      * @param T $value
47 |      *
48 |      * @return (T is null ? null : DateTime)
49 |      *
50 |      * @template T
51 |      */
52 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?DateTime
53 |     {
54 |         if ($value === null || $value instanceof DateTime) {
55 |             return $value;
56 |         }
57 | 
58 |         $dateTime = DateTime::createFromFormat('!' . $platform->getDateFormatString(), $value);
59 |         if ($dateTime !== false) {
60 |             return $dateTime;
61 |         }
62 | 
63 |         throw InvalidFormat::new(
64 |             $value,
65 |             static::class,
66 |             $platform->getDateFormatString(),
67 |         );
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Types/DecimalType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | 
 9 | use function is_float;
10 | use function is_int;
11 | 
12 | /**
13 |  * Type that maps an SQL DECIMAL to a PHP string.
14 |  */
15 | class DecimalType extends Type
16 | {
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
21 |     {
22 |         return $platform->getDecimalTypeDeclarationSQL($column);
23 |     }
24 | 
25 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?string
26 |     {
27 |         // Some drivers can represent decimals as float/int
28 |         // See also: https://github.com/doctrine/dbal/pull/4818
29 |         if (is_float($value) || is_int($value)) {
30 |             return (string) $value;
31 |         }
32 | 
33 |         return $value;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Types/EnumType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | 
 9 | final class EnumType extends Type
10 | {
11 |     /**
12 |      * {@inheritDoc}
13 |      */
14 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
15 |     {
16 |         return $platform->getEnumDeclarationSQL($column);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Types/Exception/InvalidFormat.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Doctrine\DBAL\Types\ConversionException;
 8 | use Throwable;
 9 | 
10 | use function sprintf;
11 | use function strlen;
12 | use function substr;
13 | 
14 | /**
15 |  * Thrown when a Database to Doctrine Type Conversion fails and we can make a statement
16 |  * about the expected format.
17 |  */
18 | final class InvalidFormat extends ConversionException implements TypesException
19 | {
20 |     public static function new(
21 |         string $value,
22 |         string $toType,
23 |         ?string $expectedFormat,
24 |         ?Throwable $previous = null,
25 |     ): self {
26 |         return new self(
27 |             sprintf(
28 |                 'Could not convert database value "%s" to Doctrine Type %s. Expected format "%s".',
29 |                 strlen($value) > 32 ? substr($value, 0, 20) . '...' : $value,
30 |                 $toType,
31 |                 $expectedFormat ?? '',
32 |             ),
33 |             0,
34 |             $previous,
35 |         );
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Types/Exception/InvalidType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Doctrine\DBAL\Types\ConversionException;
 8 | use Throwable;
 9 | 
10 | use function get_debug_type;
11 | use function implode;
12 | use function is_scalar;
13 | use function sprintf;
14 | use function var_export;
15 | 
16 | /**
17 |  * Thrown when the PHP value passed to the converter was not of the expected type.
18 |  */
19 | final class InvalidType extends ConversionException implements TypesException
20 | {
21 |     /**
22 |      * @param string[] $possibleTypes
23 |      *
24 |      * @todo split into two methods
25 |      * @todo sanitize value
26 |      */
27 |     public static function new(
28 |         mixed $value,
29 |         string $toType,
30 |         array $possibleTypes,
31 |         ?Throwable $previous = null,
32 |     ): self {
33 |         if (is_scalar($value) || $value === null) {
34 |             $message = sprintf(
35 |                 'Could not convert PHP value %s to type %s. Expected one of the following types: %s.',
36 |                 var_export($value, true),
37 |                 $toType,
38 |                 implode(', ', $possibleTypes),
39 |             );
40 |         } else {
41 |             $message = sprintf(
42 |                 'Could not convert PHP value of type %s to type %s. Expected one of the following types: %s.',
43 |                 get_debug_type($value),
44 |                 $toType,
45 |                 implode(', ', $possibleTypes),
46 |             );
47 |         }
48 | 
49 |         return new self($message, 0, $previous);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Types/Exception/SerializationFailed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Doctrine\DBAL\Types\ConversionException;
 8 | use Throwable;
 9 | 
10 | use function get_debug_type;
11 | use function sprintf;
12 | 
13 | final class SerializationFailed extends ConversionException implements TypesException
14 | {
15 |     public static function new(mixed $value, string $format, string $error, ?Throwable $previous = null): self
16 |     {
17 |         return new self(
18 |             sprintf(
19 |                 'Could not convert PHP type "%s" to "%s". An error was triggered by the serialization: %s',
20 |                 get_debug_type($value),
21 |                 $format,
22 |                 $error,
23 |             ),
24 |             0,
25 |             $previous,
26 |         );
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Types/Exception/TypeAlreadyRegistered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Doctrine\DBAL\Types\Type;
 8 | use Exception;
 9 | 
10 | use function get_debug_type;
11 | use function spl_object_hash;
12 | use function sprintf;
13 | 
14 | final class TypeAlreadyRegistered extends Exception implements TypesException
15 | {
16 |     public static function new(Type $type): self
17 |     {
18 |         return new self(sprintf(
19 |             'Type of the class %s@%s is already registered.',
20 |             get_debug_type($type),
21 |             spl_object_hash($type),
22 |         ));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Types/Exception/TypeNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class TypeNotFound extends Exception implements TypesException
12 | {
13 |     public static function new(string $name): self
14 |     {
15 |         return new self(sprintf('Type to be overwritten "%s" does not exist.', $name));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Types/Exception/TypeNotRegistered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Doctrine\DBAL\Types\Type;
 8 | use Exception;
 9 | 
10 | use function get_debug_type;
11 | use function spl_object_hash;
12 | use function sprintf;
13 | 
14 | final class TypeNotRegistered extends Exception implements TypesException
15 | {
16 |     public static function new(Type $type): self
17 |     {
18 |         return new self(sprintf(
19 |             'Type of the class %s@%s is not registered.',
20 |             get_debug_type($type),
21 |             spl_object_hash($type),
22 |         ));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Types/Exception/TypesAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class TypesAlreadyExists extends Exception implements TypesException
12 | {
13 |     public static function new(string $name): self
14 |     {
15 |         return new self(sprintf('Type "%s" already exists.', $name));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Types/Exception/TypesException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Doctrine\DBAL\Exception;
 8 | 
 9 | interface TypesException extends Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Types/Exception/UnknownColumnType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class UnknownColumnType extends Exception implements TypesException
12 | {
13 |     public static function new(string $name): self
14 |     {
15 |         return new self(
16 |             sprintf(
17 |                 'Unknown column type "%s" requested. Any Doctrine type that you use has '
18 |                     . 'to be registered with \Doctrine\DBAL\Types\Type::addType(). You can get a list of all the '
19 |                     . 'known types with \Doctrine\DBAL\Types\Type::getTypesMap(). If this error occurs during database '
20 |                     . 'introspection then you might have forgotten to register all database types for a Doctrine Type. '
21 |                     . 'Use AbstractPlatform#registerDoctrineTypeMapping() or have your custom types implement '
22 |                     . 'Type#getMappedDatabaseTypes(). If the type name is empty you might '
23 |                     . 'have a problem with the cache or forgot some mapping information.',
24 |                 $name,
25 |             ),
26 |         );
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Types/Exception/ValueNotConvertible.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types\Exception;
 6 | 
 7 | use Doctrine\DBAL\Types\ConversionException;
 8 | use Throwable;
 9 | 
10 | use function is_string;
11 | use function sprintf;
12 | use function strlen;
13 | use function substr;
14 | 
15 | /**
16 |  * Thrown when a Database to Doctrine Type Conversion fails.
17 |  */
18 | final class ValueNotConvertible extends ConversionException implements TypesException
19 | {
20 |     public static function new(
21 |         mixed $value,
22 |         string $toType,
23 |         ?string $message = null,
24 |         ?Throwable $previous = null,
25 |     ): self {
26 |         if ($message !== null) {
27 |             $message = sprintf(
28 |                 'Could not convert database value to "%s" as an error was triggered by the unserialization: %s',
29 |                 $toType,
30 |                 $message,
31 |             );
32 |         } else {
33 |             $message = sprintf(
34 |                 'Could not convert database value "%s" to Doctrine Type "%s".',
35 |                 is_string($value) && strlen($value) > 32 ? substr($value, 0, 20) . '...' : $value,
36 |                 $toType,
37 |             );
38 |         }
39 | 
40 |         return new self($message, 0, $previous);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Types/FloatType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | 
 9 | class FloatType extends Type
10 | {
11 |     /**
12 |      * {@inheritDoc}
13 |      */
14 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
15 |     {
16 |         return $platform->getFloatDeclarationSQL($column);
17 |     }
18 | 
19 |     /**
20 |      * @param T $value
21 |      *
22 |      * @return (T is null ? null : float)
23 |      *
24 |      * @template T
25 |      */
26 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?float
27 |     {
28 |         return $value === null ? null : (float) $value;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Types/GuidType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | 
 9 | /**
10 |  * Represents a GUID/UUID datatype (both are actually synonyms) in the database.
11 |  */
12 | class GuidType extends StringType
13 | {
14 |     /**
15 |      * {@inheritDoc}
16 |      */
17 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
18 |     {
19 |         return $platform->getGuidTypeDeclarationSQL($column);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Types/IntegerType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\ParameterType;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | 
10 | /**
11 |  * Type that maps an SQL INT to a PHP integer.
12 |  */
13 | class IntegerType extends Type implements PhpIntegerMappingType
14 | {
15 |     /**
16 |      * {@inheritDoc}
17 |      */
18 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
19 |     {
20 |         return $platform->getIntegerTypeDeclarationSQL($column);
21 |     }
22 | 
23 |     /**
24 |      * @param T $value
25 |      *
26 |      * @return (T is null ? null : int)
27 |      *
28 |      * @template T
29 |      */
30 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?int
31 |     {
32 |         return $value === null ? null : (int) $value;
33 |     }
34 | 
35 |     public function getBindingType(): ParameterType
36 |     {
37 |         return ParameterType::INTEGER;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Types/JsonType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Types\Exception\SerializationFailed;
 9 | use Doctrine\DBAL\Types\Exception\ValueNotConvertible;
10 | use JsonException;
11 | 
12 | use function is_resource;
13 | use function json_decode;
14 | use function json_encode;
15 | use function stream_get_contents;
16 | 
17 | use const JSON_PRESERVE_ZERO_FRACTION;
18 | use const JSON_THROW_ON_ERROR;
19 | 
20 | /**
21 |  * Type generating json objects values
22 |  */
23 | class JsonType extends Type
24 | {
25 |     /**
26 |      * {@inheritDoc}
27 |      */
28 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
29 |     {
30 |         return $platform->getJsonTypeDeclarationSQL($column);
31 |     }
32 | 
33 |     /**
34 |      * @param T $value
35 |      *
36 |      * @return (T is null ? null : string)
37 |      *
38 |      * @template T
39 |      */
40 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): ?string
41 |     {
42 |         if ($value === null) {
43 |             return null;
44 |         }
45 | 
46 |         try {
47 |             return json_encode($value, JSON_THROW_ON_ERROR | JSON_PRESERVE_ZERO_FRACTION);
48 |         } catch (JsonException $e) {
49 |             throw SerializationFailed::new($value, 'json', $e->getMessage(), $e);
50 |         }
51 |     }
52 | 
53 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): mixed
54 |     {
55 |         if ($value === null || $value === '') {
56 |             return null;
57 |         }
58 | 
59 |         if (is_resource($value)) {
60 |             $value = stream_get_contents($value);
61 |         }
62 | 
63 |         try {
64 |             return json_decode($value, true, 512, JSON_THROW_ON_ERROR);
65 |         } catch (JsonException $e) {
66 |             throw ValueNotConvertible::new($value, 'json', $e->getMessage(), $e);
67 |         }
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Types/PhpDateMappingType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | /**
 8 |  * Implementations should map a database type to a PHP DateTimeInterface instance.
 9 |  *
10 |  * @internal
11 |  */
12 | interface PhpDateMappingType
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Types/PhpDateTimeMappingType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | /**
 8 |  * Implementations should map a database type to a PHP DateTimeInterface instance.
 9 |  *
10 |  * @internal
11 |  */
12 | interface PhpDateTimeMappingType
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Types/PhpIntegerMappingType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | /**
 8 |  * Implementations should map a database type to a PHP integer.
 9 |  *
10 |  * @internal
11 |  */
12 | interface PhpIntegerMappingType
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Types/PhpTimeMappingType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | /**
 8 |  * Implementations should map a database type to a PHP DateTimeInterface instance.
 9 |  *
10 |  * @internal
11 |  */
12 | interface PhpTimeMappingType
13 | {
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Types/SimpleArrayType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | 
 9 | use function count;
10 | use function explode;
11 | use function implode;
12 | use function is_array;
13 | use function is_resource;
14 | use function stream_get_contents;
15 | 
16 | /**
17 |  * Array Type which can be used for simple values.
18 |  *
19 |  * Only use this type if you are sure that your values cannot contain a ",".
20 |  */
21 | class SimpleArrayType extends Type
22 | {
23 |     /**
24 |      * {@inheritDoc}
25 |      */
26 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
27 |     {
28 |         return $platform->getClobTypeDeclarationSQL($column);
29 |     }
30 | 
31 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): ?string
32 |     {
33 |         if (! is_array($value) || count($value) === 0) {
34 |             return null;
35 |         }
36 | 
37 |         return implode(',', $value);
38 |     }
39 | 
40 |     /** @return list<string> */
41 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): array
42 |     {
43 |         if ($value === null) {
44 |             return [];
45 |         }
46 | 
47 |         $value = is_resource($value) ? stream_get_contents($value) : $value;
48 | 
49 |         return explode(',', $value);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Types/SmallFloatType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | 
 9 | class SmallFloatType extends Type
10 | {
11 |     /**
12 |      * {@inheritDoc}
13 |      */
14 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
15 |     {
16 |         return $platform->getSmallFloatDeclarationSQL($column);
17 |     }
18 | 
19 |     /**
20 |      * @param T $value
21 |      *
22 |      * @return (T is null ? null : float)
23 |      *
24 |      * @template T
25 |      */
26 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?float
27 |     {
28 |         return $value === null ? null : (float) $value;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Types/SmallIntType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\ParameterType;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | 
10 | /**
11 |  * Type that maps a database SMALLINT to a PHP integer.
12 |  */
13 | class SmallIntType extends Type implements PhpIntegerMappingType
14 | {
15 |     /**
16 |      * {@inheritDoc}
17 |      */
18 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
19 |     {
20 |         return $platform->getSmallIntTypeDeclarationSQL($column);
21 |     }
22 | 
23 |     /**
24 |      * @param T $value
25 |      *
26 |      * @return (T is null ? null : int)
27 |      *
28 |      * @template T
29 |      */
30 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?int
31 |     {
32 |         return $value === null ? null : (int) $value;
33 |     }
34 | 
35 |     public function getBindingType(): ParameterType
36 |     {
37 |         return ParameterType::INTEGER;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Types/StringType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | 
 9 | /**
10 |  * Type that maps an SQL VARCHAR to a PHP string.
11 |  */
12 | class StringType extends Type
13 | {
14 |     /**
15 |      * {@inheritDoc}
16 |      */
17 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
18 |     {
19 |         return $platform->getStringTypeDeclarationSQL($column);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Types/TextType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | 
 9 | use function is_resource;
10 | use function stream_get_contents;
11 | 
12 | /**
13 |  * Type that maps an SQL CLOB to a PHP string.
14 |  */
15 | class TextType extends Type
16 | {
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
21 |     {
22 |         return $platform->getClobTypeDeclarationSQL($column);
23 |     }
24 | 
25 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): mixed
26 |     {
27 |         return is_resource($value) ? stream_get_contents($value) : $value;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Types/TimeImmutableType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use DateTimeImmutable;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | use Doctrine\DBAL\Types\Exception\InvalidFormat;
10 | use Doctrine\DBAL\Types\Exception\InvalidType;
11 | 
12 | /**
13 |  * Immutable type of {@see TimeType}.
14 |  */
15 | class TimeImmutableType extends Type implements PhpTimeMappingType
16 | {
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
21 |     {
22 |         return $platform->getTimeTypeDeclarationSQL($column);
23 |     }
24 | 
25 |     /**
26 |      * @param T $value
27 |      *
28 |      * @return (T is null ? null : string)
29 |      *
30 |      * @template T
31 |      */
32 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): ?string
33 |     {
34 |         if ($value === null) {
35 |             return $value;
36 |         }
37 | 
38 |         if ($value instanceof DateTimeImmutable) {
39 |             return $value->format($platform->getTimeFormatString());
40 |         }
41 | 
42 |         throw InvalidType::new(
43 |             $value,
44 |             static::class,
45 |             ['null', DateTimeImmutable::class],
46 |         );
47 |     }
48 | 
49 |     /**
50 |      * @param T $value
51 |      *
52 |      * @return (T is null ? null : DateTimeImmutable)
53 |      *
54 |      * @template T
55 |      */
56 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?DateTimeImmutable
57 |     {
58 |         if ($value === null || $value instanceof DateTimeImmutable) {
59 |             return $value;
60 |         }
61 | 
62 |         $dateTime = DateTimeImmutable::createFromFormat('!' . $platform->getTimeFormatString(), $value);
63 | 
64 |         if ($dateTime !== false) {
65 |             return $dateTime;
66 |         }
67 | 
68 |         throw InvalidFormat::new(
69 |             $value,
70 |             static::class,
71 |             $platform->getTimeFormatString(),
72 |         );
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/Types/TimeType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use DateTime;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | use Doctrine\DBAL\Types\Exception\InvalidFormat;
10 | use Doctrine\DBAL\Types\Exception\InvalidType;
11 | 
12 | /**
13 |  * Type that maps an SQL TIME to a PHP DateTime object.
14 |  */
15 | class TimeType extends Type implements PhpTimeMappingType
16 | {
17 |     /**
18 |      * {@inheritDoc}
19 |      */
20 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
21 |     {
22 |         return $platform->getTimeTypeDeclarationSQL($column);
23 |     }
24 | 
25 |     /**
26 |      * @param T $value
27 |      *
28 |      * @return (T is null ? null : string)
29 |      *
30 |      * @template T
31 |      */
32 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): ?string
33 |     {
34 |         if ($value === null) {
35 |             return $value;
36 |         }
37 | 
38 |         if ($value instanceof DateTime) {
39 |             return $value->format($platform->getTimeFormatString());
40 |         }
41 | 
42 |         throw InvalidType::new($value, static::class, ['null', DateTime::class]);
43 |     }
44 | 
45 |     /**
46 |      * @param T $value
47 |      *
48 |      * @return (T is null ? null : DateTime)
49 |      *
50 |      * @template T
51 |      */
52 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?DateTime
53 |     {
54 |         if ($value === null || $value instanceof DateTime) {
55 |             return $value;
56 |         }
57 | 
58 |         $dateTime = DateTime::createFromFormat('!' . $platform->getTimeFormatString(), $value);
59 |         if ($dateTime !== false) {
60 |             return $dateTime;
61 |         }
62 | 
63 |         throw InvalidFormat::new(
64 |             $value,
65 |             static::class,
66 |             $platform->getTimeFormatString(),
67 |         );
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Types/Types.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | /**
 8 |  * Default built-in types provided by Doctrine DBAL.
 9 |  */
10 | final class Types
11 | {
12 |     public const ASCII_STRING         = 'ascii_string';
13 |     public const BIGINT               = 'bigint';
14 |     public const BINARY               = 'binary';
15 |     public const BLOB                 = 'blob';
16 |     public const BOOLEAN              = 'boolean';
17 |     public const DATE_MUTABLE         = 'date';
18 |     public const DATE_IMMUTABLE       = 'date_immutable';
19 |     public const DATEINTERVAL         = 'dateinterval';
20 |     public const DATETIME_MUTABLE     = 'datetime';
21 |     public const DATETIME_IMMUTABLE   = 'datetime_immutable';
22 |     public const DATETIMETZ_MUTABLE   = 'datetimetz';
23 |     public const DATETIMETZ_IMMUTABLE = 'datetimetz_immutable';
24 |     public const DECIMAL              = 'decimal';
25 |     public const FLOAT                = 'float';
26 |     public const ENUM                 = 'enum';
27 |     public const GUID                 = 'guid';
28 |     public const INTEGER              = 'integer';
29 |     public const JSON                 = 'json';
30 |     public const SIMPLE_ARRAY         = 'simple_array';
31 |     public const SMALLFLOAT           = 'smallfloat';
32 |     public const SMALLINT             = 'smallint';
33 |     public const STRING               = 'string';
34 |     public const TEXT                 = 'text';
35 |     public const TIME_MUTABLE         = 'time';
36 |     public const TIME_IMMUTABLE       = 'time_immutable';
37 | 
38 |     /** @codeCoverageIgnore */
39 |     private function __construct()
40 |     {
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Types/VarDateTimeImmutableType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use DateTimeImmutable;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | use Doctrine\DBAL\Types\Exception\InvalidType;
10 | use Doctrine\DBAL\Types\Exception\ValueNotConvertible;
11 | use Exception;
12 | 
13 | /**
14 |  * Immutable type of {@see VarDateTimeType}.
15 |  */
16 | class VarDateTimeImmutableType extends DateTimeImmutableType
17 | {
18 |     /**
19 |      * @param T $value
20 |      *
21 |      * @return (T is null ? null : string)
22 |      *
23 |      * @template T
24 |      */
25 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): ?string
26 |     {
27 |         if ($value === null) {
28 |             return $value;
29 |         }
30 | 
31 |         if ($value instanceof DateTimeImmutable) {
32 |             return $value->format($platform->getDateTimeFormatString());
33 |         }
34 | 
35 |         throw InvalidType::new(
36 |             $value,
37 |             static::class,
38 |             ['null', DateTimeImmutable::class],
39 |         );
40 |     }
41 | 
42 |     /**
43 |      * @param T $value
44 |      *
45 |      * @return (T is null ? null : DateTimeImmutable)
46 |      *
47 |      * @template T
48 |      */
49 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?DateTimeImmutable
50 |     {
51 |         if ($value === null || $value instanceof DateTimeImmutable) {
52 |             return $value;
53 |         }
54 | 
55 |         try {
56 |             $dateTime = new DateTimeImmutable($value);
57 |         } catch (Exception $e) {
58 |             throw ValueNotConvertible::new($value, DateTimeImmutable::class, $e->getMessage(), $e);
59 |         }
60 | 
61 |         return $dateTime;
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/Types/VarDateTimeType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Doctrine\DBAL\Types;
 6 | 
 7 | use DateTime;
 8 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 9 | use Doctrine\DBAL\Types\Exception\ValueNotConvertible;
10 | use Exception;
11 | 
12 | /**
13 |  * Variable DateTime Type using DateTime::__construct() instead of DateTime::createFromFormat().
14 |  *
15 |  * This type has performance implications as it runs twice as long as the regular
16 |  * {@see DateTimeType}, however in certain PostgreSQL configurations with
17 |  * TIMESTAMP(n) columns where n > 0 it is necessary to use this type.
18 |  */
19 | class VarDateTimeType extends DateTimeType
20 | {
21 |     /**
22 |      * @param T $value
23 |      *
24 |      * @return (T is null ? null : DateTime)
25 |      *
26 |      * @template T
27 |      */
28 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?DateTime
29 |     {
30 |         if ($value === null || $value instanceof DateTime) {
31 |             return $value;
32 |         }
33 | 
34 |         try {
35 |             $dateTime = new DateTime($value);
36 |         } catch (Exception $e) {
37 |             throw ValueNotConvertible::new($value, DateTime::class, $e->getMessage(), $e);
38 |         }
39 | 
40 |         return $dateTime;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------