try {
            $this->parser->parse($sql, $visitor);
        } catch (Parser\Exception $e) {
            throw ParseError::fromParserException($e);
        }
 
        return [
            $visitor->getSQL(),
            $visitor->getParameters(),
            $visitor->getTypes(),
        ];
    }
 
    private function handleDriverException(
        Driver\Exception $driverException,
        ?Query $query,
    ): DriverException {
        $this->exceptionConverter ??= $this->driver->getExceptionConverter();
        $exception                  = $this->exceptionConverter->convert($driverException, $query);
 
        if ($exception instanceof ConnectionLost) {
            $this->close();
        }
 
        return $exception;
    }
}
 

 
    /**
     * @internal
     *
     * @param list<mixed>|array<string,mixed> $params
     * @phpstan-param WrapperParameterTypeArray $types
     */
    final public function convertExceptionDuringQuery(
        Driver\Exception $e,
        string $sql,
        array $params = [],
        array $types = [],
    ): DriverException {
        return $this->handleDriverException($e, new Query($sql, $params, $types));
    }
 
    /** @internal */
    final public function convertException(Driver\Exception $e): DriverException
    {
        return $this->handleDriverException($e, null);
    }
 
    /**
     * @param list<mixed>|array<string, mixed> $params
     * @phpstan-param WrapperParameterTypeArray $types
     *
     * @return array{
     *     string,
     *     list<mixed>|array<string, mixed>,
     *     array<int<0, max>, string|ParameterType|Type>|array<string, string|ParameterType|Type>
     * }
     *
     * @throws Exception
     */
    private function expandArrayParameters(string $sql, array $params, array $types): array
    {
        $needsConversion = false;
        $nonArrayTypes   = [];
 
        if (is_string(key($params))) {

    public function createExpressionBuilder(): ExpressionBuilder
    {
        return new ExpressionBuilder($this);
    }
 
    /**
     * Establishes the connection with the database and returns the underlying connection.
     *
     * @throws Exception
     */
    protected function connect(): DriverConnection
    {
        if ($this->_conn !== null) {
            return $this->_conn;
        }
 
        try {
            $connection = $this->_conn = $this->driver->connect($this->params);
        } catch (Driver\Exception $e) {
            throw $this->convertException($e);
        }
 
        if ($this->autoCommit === false) {
            $this->beginTransaction();
        }
 
        return $connection;
    }
 
    /**
     * {@inheritDoc}
     *
     * @throws Exception
     */
    public function getServerVersion(): string
    {
        return $this->connect()->getServerVersion();
    }
 
    /**

namespace Doctrine\DBAL\Driver\PDO;
 
use Doctrine\DBAL\Driver\AbstractException;
use PDOException;
 
/** @internal */
final class Exception extends AbstractException
{
    public static function new(PDOException $exception): self
    {
        if ($exception->errorInfo !== null) {
            [$sqlState, $code] = $exception->errorInfo;
 
            $code ??= 0;
        } else {
            $code     = $exception->getCode();
            $sqlState = null;
        }
 
        return new self($exception->getMessage(), $sqlState, $code, $exception);
    }
}
 

        }
 
        foreach (['user', 'password'] as $key) {
            if (isset($params[$key]) && ! is_string($params[$key])) {
                throw InvalidConfiguration::notAStringOrNull($key, $params[$key]);
            }
        }
 
        $safeParams = $params;
        unset($safeParams['password']);
 
        try {
            $pdo = $this->doConnect(
                $this->constructPdoDsn($safeParams),
                $params['user'] ?? '',
                $params['password'] ?? '',
                $driverOptions,
            );
        } catch (PDOException $exception) {
            throw Exception::new($exception);
        }
 
        return new Connection($pdo);
    }
 
    /**
     * Constructs the MySQL PDO DSN.
     *
     * @param mixed[] $params
     */
    private function constructPdoDsn(array $params): string
    {
        $dsn = 'mysql:';
        if (isset($params['host']) && $params['host'] !== '') {
            $dsn .= 'host=' . $params['host'] . ';';
        }
 
        if (isset($params['port'])) {
            $dsn .= 'port=' . $params['port'] . ';';
        }

 
use PDO;
use SensitiveParameter;
 
use const PHP_VERSION_ID;
 
/** @internal */
trait PDOConnect
{
    /** @param array<int, mixed> $options */
    private function doConnect(
        #[SensitiveParameter]
        string $dsn,
        string $username,
        #[SensitiveParameter]
        string $password,
        array $options,
    ): PDO {
        if (PHP_VERSION_ID < 80400) {
            return new PDO($dsn, $username, $password, $options);
        }
 
        return PDO::connect($dsn, $username, $password, $options);
    }
}
 

 
use PDO;
use SensitiveParameter;
 
use const PHP_VERSION_ID;
 
/** @internal */
trait PDOConnect
{
    /** @param array<int, mixed> $options */
    private function doConnect(
        #[SensitiveParameter]
        string $dsn,
        string $username,
        #[SensitiveParameter]
        string $password,
        array $options,
    ): PDO {
        if (PHP_VERSION_ID < 80400) {
            return new PDO($dsn, $username, $password, $options);
        }
 
        return PDO::connect($dsn, $username, $password, $options);
    }
}
 

        #[SensitiveParameter]
        array $params,
    ): Connection {
        $driverOptions = $params['driverOptions'] ?? [];
 
        if (! empty($params['persistent'])) {
            $driverOptions[PDO::ATTR_PERSISTENT] = true;
        }
 
        foreach (['user', 'password'] as $key) {
            if (isset($params[$key]) && ! is_string($params[$key])) {
                throw InvalidConfiguration::notAStringOrNull($key, $params[$key]);
            }
        }
 
        $safeParams = $params;
        unset($safeParams['password']);
 
        try {
            $pdo = $this->doConnect(
                $this->constructPdoDsn($safeParams),
                $params['user'] ?? '',
                $params['password'] ?? '',
                $driverOptions,
            );
        } catch (PDOException $exception) {
            throw Exception::new($exception);
        }
 
        return new Connection($pdo);
    }
 
    /**
     * Constructs the MySQL PDO DSN.
     *
     * @param mixed[] $params
     */
    private function constructPdoDsn(array $params): string
    {
        $dsn = 'mysql:';

     * Creates an expression builder for the connection.
     */
    public function createExpressionBuilder(): ExpressionBuilder
    {
        return new ExpressionBuilder($this);
    }
 
    /**
     * Establishes the connection with the database and returns the underlying connection.
     *
     * @throws Exception
     */
    protected function connect(): DriverConnection
    {
        if ($this->_conn !== null) {
            return $this->_conn;
        }
 
        try {
            $connection = $this->_conn = $this->driver->connect($this->params);
        } catch (Driver\Exception $e) {
            throw $this->convertException($e);
        }
 
        if ($this->autoCommit === false) {
            $this->beginTransaction();
        }
 
        return $connection;
    }
 
    /**
     * {@inheritDoc}
     *
     * @throws Exception
     */
    public function getServerVersion(): string
    {
        return $this->connect()->getServerVersion();
    }

    {
        $platform = $this->getDatabasePlatform();
 
        if (! $platform->supportsSavepoints()) {
            throw SavepointsNotSupported::new();
        }
 
        $this->executeStatement($platform->rollbackSavePoint($savepoint));
    }
 
    /**
     * Provides access to the native database connection.
     *
     * @return resource|object
     *
     * @throws Exception
     */
    public function getNativeConnection()
    {
        return $this->connect()->getNativeConnection();
    }
 
    /**
     * Creates a SchemaManager that can be used to inspect or change the
     * database schema through the connection.
     *
     * @throws Exception
     */
    public function createSchemaManager(): AbstractSchemaManager
    {
        return $this->schemaManagerFactory->createSchemaManager($this);
    }
 
    /**
     * Marks the current transaction so that the only possible
     * outcome for the transaction to be rolled back.
     *
     * @throws ConnectionException If no transaction is active.
     */
    public function setRollbackOnly(): void

    return $crypt;
};
 
/*
 * Creates a new PDO object for database connections
 *
 * @param void
 *
 * @return PDO The PDO object used for database connections
 */
$di['pdo'] = function () {
    $debugConfig = Config::getProperty('debug_and_monitoring', []);
    $dbConfig = DriverManagerFactory::getDatabaseConfig();
    $driverOptions = [
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    ];
 
    $connection = DriverManagerFactory::getConnection($driverOptions);
    /** @var PDO $pdo */
    $pdo = $connection->getNativeConnection();
 
    if (isset($debugConfig['debug']) && $debugConfig['debug']) {
        $pdo->setAttribute(PDO::ATTR_STATEMENT_CLASS, ['Box_DbLoggedPDOStatement']);
    }
 
    if ($dbConfig['driver'] === 'pdo_mysql') {
        // Set server default charset for newly created tables. Connection charset is handled by DBAL via DSN.
        $pdo->exec('SET character_set_server = utf8');
        $pdo->exec('SET SESSION interactive_timeout = 28800');
        $pdo->exec('SET SESSION wait_timeout = 28800');
 
        // Get the timezone offset in the PDO format
        $datetime = new DateTime('now');
        $offset = $datetime->format('P');
        $pdo->exec("SET time_zone = '{$offset}'");
    }
 
    return new DebugBar\DataCollector\PDO\TraceablePDO($pdo);
};
 

    {
        if (!isset($this->keys[$id])) {
            throw new UnknownIdentifierException($id);
        }
 
        if (
            isset($this->raw[$id])
            || !\is_object($this->values[$id])
            || isset($this->protected[$this->values[$id]])
            || !\method_exists($this->values[$id], '__invoke')
        ) {
            return $this->values[$id];
        }
 
        if (isset($this->factories[$this->values[$id]])) {
            return $this->values[$id]($this);
        }
 
        $raw = $this->values[$id];
        $val = $this->values[$id] = $raw($this);
        $this->raw[$id] = $raw;
 
        $this->frozen[$id] = true;
 
        return $val;
    }
 
    /**
     * Checks if a parameter or an object is set.
     *
     * @param string $id The unique identifier for the parameter or object
     *
     * @return bool
     */
    #[\ReturnTypeWillChange]
    public function offsetExists($id)
    {
        return isset($this->keys[$id]);
    }
 

$config = FOSSBilling\Config::getConfig();
$debugBar = null;
$timeCollector = null;
/* @var Symfony\Component\HttpFoundation\Request $request */
global $request;
 
if ((bool) ($config['debug_and_monitoring']['debug'] ?? false)) {
    // Setting up the debug bar
    $debugBar = new DebugBar\StandardDebugBar();
    $timeCollector = $debugBar->getCollector('time');
 
    if (!$timeCollector instanceof TimeDataCollector) {
        throw new RuntimeException('Time collector not found in debug bar.');
    }
 
    // PDO collector
    $pdoCollector = new DebugBar\DataCollector\PDO\PDOCollector();
 
    // RedBean
    $pdoCollector->addConnection($di['pdo'], 'RedBeanPHP');
 
    // Doctrine
    $connection = $di['em']->getConnection();
    $native = $connection->getNativeConnection();
 
    if ($native instanceof PDO) {
        $pdoCollector->addConnection(new DebugBar\DataCollector\PDO\TraceablePDO($native), 'Doctrine');
    }
 
    $debugBar->addCollector($pdoCollector);
 
    $config['info']['salt'] = '********';
    $config['db'] = array_fill_keys(array_keys($config['db']), '********');
 
    $configCollector = new DebugBar\DataCollector\ConfigCollector($config);
 
    $debugBar->addCollector($configCollector);
}
 
$url = RequestFactory::normalizeRoutePath($request);