FM / Database

/var/www/vhosts/ihelp.ro/httpdocs/vendor/cakephp/cakephp/src/Database/

/var/www/vhosts/ihelp.ro/httpdocs/vendor/cakephp/cakephp/src/Database

Name	Size	Mode	Actions
Driver/	-	0755	rm
Exception/	-	0755	rm
Expression/	-	0755	rm
Log/	-	0755	rm
Retry/	-	0755	rm
Schema/	-	0755	rm
Statement/	-	0755	rm
Type/	-	0755	rm
composer.json	1192	0644	edit dl rm
Connection.php	29032	0644	edit dl rm
ConstraintsInterface.php	1842	0644	edit dl rm
Driver.php	13021	0644	edit dl rm
DriverInterface.php	9588	0644	edit dl rm
Exception.php	572	0644	edit dl rm
ExpressionInterface.php	1367	0644	edit dl rm
FieldTypeConverter.php	4404	0644	edit dl rm
FunctionsBuilder.php	14662	0644	edit dl rm
IdentifierQuoter.php	7962	0644	edit dl rm
LICENSE.txt	1204	0644	edit dl rm
PostgresCompiler.php	2803	0644	edit dl rm
Query.php	82857	0644	edit dl rm
QueryCompiler.php	16899	0644	edit dl rm
README.md	10566	0644	edit dl rm
SchemaCache.php	3430	0644	edit dl rm
SqlDialectTrait.php	171	0644	edit dl rm
SqliteCompiler.php	937	0644	edit dl rm
SqlserverCompiler.php	5410	0644	edit dl rm
StatementInterface.php	6777	0644	edit dl rm
Type.php	165	0644	edit dl rm
TypeConverterTrait.php	2197	0644	edit dl rm
TypedResultInterface.php	1093	0644	edit dl rm
TypedResultTrait.php	1356	0644	edit dl rm
TypeFactory.php	5402	0644	edit dl rm
TypeInterface.php	3334	0644	edit dl rm
TypeMap.php	4587	0644	edit dl rm
TypeMapTrait.php	2389	0644	edit dl rm
ValueBinder.php	4533	0644	edit dl rm

Edit: /var/www/vhosts/ihelp.ro/httpdocs/vendor/cakephp/cakephp/src/Database/Driver.php (13021B)

<?php
declare(strict_types=1);

/**
 * CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 * @link          https://cakephp.org CakePHP(tm) Project
 * @since         3.0.0
 * @license       https://opensource.org/licenses/mit-license.php MIT License
 */
namespace Cake\Database;

use Cake\Core\App;
use Cake\Core\Retry\CommandRetry;
use Cake\Database\Exception\MissingConnectionException;
use Cake\Database\Retry\ErrorCodeWaitStrategy;
use Cake\Database\Schema\SchemaDialect;
use Cake\Database\Schema\TableSchema;
use Cake\Database\Statement\PDOStatement;
use Closure;
use InvalidArgumentException;
use PDO;
use PDOException;

/**
 * Represents a database driver containing all specificities for
 * a database engine including its SQL dialect.
 */
abstract class Driver implements DriverInterface
{
    /**
     * @var int|null Maximum alias length or null if no limit
     */
    protected const MAX_ALIAS_LENGTH = null;

/**
     * @var array<int>  DB-specific error codes that allow connect retry
     */
    protected const RETRY_ERROR_CODES = [];

/**
     * Instance of PDO.
     *
     * @var \PDO
     */
    protected $_connection;

/**
     * Configuration data.
     *
     * @var array<string, mixed>
     */
    protected $_config;

/**
     * Base configuration that is merged into the user
     * supplied configuration data.
     *
     * @var array<string, mixed>
     */
    protected $_baseConfig = [];

/**
     * Indicates whether the driver is doing automatic identifier quoting
     * for all queries
     *
     * @var bool
     */
    protected $_autoQuoting = false;

/**
     * The server version
     *
     * @var string|null
     */
    protected $_version;

/**
     * The last number of connection retry attempts.
     *
     * @var int
     */
    protected $connectRetries = 0;

/**
     * Constructor
     *
     * @param array<string, mixed> $config The configuration for the driver.
     * @throws \InvalidArgumentException
     */
    public function __construct(array $config = [])
    {
        if (empty($config['username']) && !empty($config['login'])) {
            throw new InvalidArgumentException(
                'Please pass "username" instead of "login" for connecting to the database'
            );
        }
        $config += $this->_baseConfig;
        $this->_config = $config;
        if (!empty($config['quoteIdentifiers'])) {
            $this->enableAutoQuoting();
        }
    }

/**
     * Establishes a connection to the database server
     *
     * @param string $dsn A Driver-specific PDO-DSN
     * @param array<string, mixed> $config configuration to be used for creating connection
     * @return bool true on success
     */
    protected function _connect(string $dsn, array $config): bool
    {
        $action = function () use ($dsn, $config) {
            $this->setConnection(new PDO(
                $dsn,
                $config['username'] ?: null,
                $config['password'] ?: null,
                $config['flags']
            ));
        };

$retry = new CommandRetry(new ErrorCodeWaitStrategy(static::RETRY_ERROR_CODES, 5), 4);
        try {
            $retry->run($action);
        } catch (PDOException $e) {
            throw new MissingConnectionException(
                [
                    'driver' => App::shortName(static::class, 'Database/Driver'),
                    'reason' => $e->getMessage(),
                ],
                null,
                $e
            );
        } finally {
            $this->connectRetries = $retry->getRetries();
        }

return true;
    }

/**
     * @inheritDoc
     */
    abstract public function connect(): bool;

/**
     * @inheritDoc
     */
    public function disconnect(): void
    {
        /** @psalm-suppress PossiblyNullPropertyAssignmentValue */
        $this->_connection = null;
        $this->_version = null;
    }

/**
     * Returns connected server version.
     *
     * @return string
     */
    public function version(): string
    {
        if ($this->_version === null) {
            $this->connect();
            $this->_version = (string)$this->_connection->getAttribute(PDO::ATTR_SERVER_VERSION);
        }

return $this->_version;
    }

/**
     * Get the internal PDO connection instance.
     *
     * @return \PDO
     */
    public function getConnection()
    {
        if ($this->_connection === null) {
            throw new MissingConnectionException([
                'driver' => App::shortName(static::class, 'Database/Driver'),
                'reason' => 'Unknown',
            ]);
        }

return $this->_connection;
    }

/**
     * Set the internal PDO connection instance.
     *
     * @param \PDO $connection PDO instance.
     * @return $this
     * @psalm-suppress MoreSpecificImplementedParamType
     */
    public function setConnection($connection)
    {
        $this->_connection = $connection;

return $this;
    }

/**
     * @inheritDoc
     */
    abstract public function enabled(): bool;

/**
     * @inheritDoc
     */
    public function prepare($query): StatementInterface
    {
        $this->connect();
        $statement = $this->_connection->prepare($query instanceof Query ? $query->sql() : $query);

return new PDOStatement($statement, $this);
    }

/**
     * @inheritDoc
     */
    public function beginTransaction(): bool
    {
        $this->connect();
        if ($this->_connection->inTransaction()) {
            return true;
        }

return $this->_connection->beginTransaction();
    }

/**
     * @inheritDoc
     */
    public function commitTransaction(): bool
    {
        $this->connect();
        if (!$this->_connection->inTransaction()) {
            return false;
        }

return $this->_connection->commit();
    }

/**
     * @inheritDoc
     */
    public function rollbackTransaction(): bool
    {
        $this->connect();
        if (!$this->_connection->inTransaction()) {
            return false;
        }

return $this->_connection->rollBack();
    }

/**
     * Returns whether a transaction is active for connection.
     *
     * @return bool
     */
    public function inTransaction(): bool
    {
        $this->connect();

return $this->_connection->inTransaction();
    }

/**
     * @inheritDoc
     */
    public function supportsSavePoints(): bool
    {
        deprecationWarning('Feature support checks are now implemented by `supports()` with FEATURE_* constants.');

return $this->supports(static::FEATURE_SAVEPOINT);
    }

/**
     * Returns true if the server supports common table expressions.
     *
     * @return bool
     * @deprecated 4.3.0 Use `supports(DriverInterface::FEATURE_QUOTE)` instead
     */
    public function supportsCTEs(): bool
    {
        deprecationWarning('Feature support checks are now implemented by `supports()` with FEATURE_* constants.');

return $this->supports(static::FEATURE_CTE);
    }

/**
     * @inheritDoc
     */
    public function quote($value, $type = PDO::PARAM_STR): string
    {
        $this->connect();

return $this->_connection->quote((string)$value, $type);
    }

/**
     * Checks if the driver supports quoting, as PDO_ODBC does not support it.
     *
     * @return bool
     * @deprecated 4.3.0 Use `supports(DriverInterface::FEATURE_QUOTE)` instead
     */
    public function supportsQuoting(): bool
    {
        deprecationWarning('Feature support checks are now implemented by `supports()` with FEATURE_* constants.');

return $this->supports(static::FEATURE_QUOTE);
    }

/**
     * @inheritDoc
     */
    abstract public function queryTranslator(string $type): Closure;

/**
     * @inheritDoc
     */
    abstract public function schemaDialect(): SchemaDialect;

/**
     * @inheritDoc
     */
    abstract public function quoteIdentifier(string $identifier): string;

/**
     * @inheritDoc
     */
    public function schemaValue($value): string
    {
        if ($value === null) {
            return 'NULL';
        }
        if ($value === false) {
            return 'FALSE';
        }
        if ($value === true) {
            return 'TRUE';
        }
        if (is_float($value)) {
            return str_replace(',', '.', (string)$value);
        }
        /** @psalm-suppress InvalidArgument */
        if (
            (
                is_int($value) ||
                $value === '0'
            ) ||
            (
                is_numeric($value) &&
                strpos($value, ',') === false &&
                substr($value, 0, 1) !== '0' &&
                strpos($value, 'e') === false
            )
        ) {
            return (string)$value;
        }

return $this->_connection->quote((string)$value, PDO::PARAM_STR);
    }

/**
     * @inheritDoc
     */
    public function schema(): string
    {
        return $this->_config['schema'];
    }

/**
     * @inheritDoc
     */
    public function lastInsertId(?string $table = null, ?string $column = null)
    {
        $this->connect();

if ($this->_connection instanceof PDO) {
            return $this->_connection->lastInsertId($table);
        }

return $this->_connection->lastInsertId($table);
    }

/**
     * @inheritDoc
     */
    public function isConnected(): bool
    {
        if ($this->_connection === null) {
            $connected = false;
        } else {
            try {
                $connected = (bool)$this->_connection->query('SELECT 1');
            } catch (PDOException $e) {
                $connected = false;
            }
        }

return $connected;
    }

/**
     * @inheritDoc
     */
    public function enableAutoQuoting(bool $enable = true)
    {
        $this->_autoQuoting = $enable;

return $this;
    }

/**
     * @inheritDoc
     */
    public function disableAutoQuoting()
    {
        $this->_autoQuoting = false;

return $this;
    }

/**
     * @inheritDoc
     */
    public function isAutoQuotingEnabled(): bool
    {
        return $this->_autoQuoting;
    }

/**
     * Returns whether the driver supports the feature.
     *
     * Defaults to true for FEATURE_QUOTE and FEATURE_SAVEPOINT.
     *
     * @param string $feature Driver feature name
     * @return bool
     */
    public function supports(string $feature): bool
    {
        switch ($feature) {
            case static::FEATURE_DISABLE_CONSTRAINT_WITHOUT_TRANSACTION:
            case static::FEATURE_QUOTE:
            case static::FEATURE_SAVEPOINT:
                return true;
        }

return false;
    }

/**
     * @inheritDoc
     */
    public function compileQuery(Query $query, ValueBinder $binder): array
    {
        $processor = $this->newCompiler();
        $translator = $this->queryTranslator($query->type());
        $query = $translator($query);

return [$query, $processor->compile($query, $binder)];
    }

/**
     * @inheritDoc
     */
    public function newCompiler(): QueryCompiler
    {
        return new QueryCompiler();
    }

/**
     * @inheritDoc
     */
    public function newTableSchema(string $table, array $columns = []): TableSchema
    {
        $className = TableSchema::class;
        if (isset($this->_config['tableSchema'])) {
            /** @var class-string<\Cake\Database\Schema\TableSchema> $className */
            $className = $this->_config['tableSchema'];
        }

return new $className($table, $columns);
    }

/**
     * Returns the maximum alias length allowed.
     * This can be different from the maximum identifier length for columns.
     *
     * @return int|null Maximum alias length or null if no limit
     */
    public function getMaxAliasLength(): ?int
    {
        return static::MAX_ALIAS_LENGTH;
    }

/**
     * Returns the number of connection retry attempts made.
     *
     * @return int
     */
    public function getConnectRetries(): int
    {
        return $this->connectRetries;
    }

/**
     * Destructor
     */
    public function __destruct()
    {
        /** @psalm-suppress PossiblyNullPropertyAssignmentValue */
        $this->_connection = null;
    }

/**
     * Returns an array that can be used to describe the internal state of this
     * object.
     *
     * @return array<string, mixed>
     */
    public function __debugInfo(): array
    {
        return [
            'connected' => $this->_connection !== null,
        ];
    }
}

cmd: