Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork\DataSource;

use Clockwork\Request\Request;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Logging\LoggerChain;
use Doctrine\DBAL\Logging\SQLLogger;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\Type;

// Data source for DBAL, provides database queries
class DBALDataSource extends DataSource implements SQLLogger
{
        // Array of collected queries
        protected $queries = [];

        // Current running query
        protected $query = null;

        // DBAL connection
        protected $connection;

        // DBAL connection name
        protected $connectionName;

        // Create a new data source instance, takes a DBAL connection instance as an argument
        public function __construct(Connection $connection)
        {
                $this->connection = $connection;
                $this->connectionName = $this->connection->getDatabase();

                $configuration = $this->connection->getConfiguration();
                $currentLogger = $configuration->getSQLLogger();

                if ($currentLogger === null) {
                        $configuration->setSQLLogger($this);
                } else {
                        $loggerChain = new LoggerChain;
                        $loggerChain->addLogger($currentLogger);
                        $loggerChain->addLogger($this);

                        $configuration->setSQLLogger($loggerChain);
                }
        }

        // Adds executed database queries to the request
        public function resolve(Request $request)
        {
                $request->databaseQueries = array_merge($request->databaseQueries, $this->queries);

                return $request;
        }

        // Reset the data source to an empty state, clearing any collected data
        public function reset()
        {
                $this->queries = [];
                $this->query = null;
        }

        // DBAL SQLLogger event
        public function startQuery($sql, array $params = null, array $types = null)
        {
                $this->query = [
                        'query'  => $sql,
                        'params' => $params,
                        'types'  => $types,
                        'time'   => microtime(true)
                ];
        }

        // DBAL SQLLogger event
        public function stopQuery()
        {
                $this->registerQuery($this->query);
                $this->query = null;
        }

        // Collect an executed database query
        protected function registerQuery($query)
        {
                $query = [
                        'query'      => $this->createRunnableQuery($query['query'], $query['params'], $query['types']),
                        'bindings'   => $query['params'],
                        'duration'   => (microtime(true) - $query['time']) * 1000,
                        'connection' => $this->connectionName,
                        'time'       => $query['time']
                ];

                if ($this->passesFilters([ $query ])) {
                        $this->queries[] = $query;
                }
        }

        // Takes a query, an array of params and types as arguments, returns runnable query with upper-cased keywords
        protected function createRunnableQuery($query, $params, $types)
        {
                // add params to query
                $query = $this->replaceParams($this->connection->getDatabasePlatform(), $query, $params, $types);

                // highlight keywords
                $keywords = [
                        'select', 'insert', 'update', 'delete', 'into', 'values', 'set', 'where', 'from', 'limit', 'is', 'null',
                        'having', 'group by', 'order by', 'asc', 'desc'
                ];
                $regexp = '/\b' . implode('\b|\b', $keywords) . '\b/i';

                return preg_replace_callback($regexp, function ($match) { return strtoupper($match[0]); }, $query);
        }

        /**
         * Source at laravel-doctrine/orm LaravelDoctrine\ORM\Loggers\Formatters\ReplaceQueryParams::format().
         *
         * @param AbstractPlatform $platform
         * @param string           $sql
         * @param array|null       $params
         * @param array|null       $types
         *
         *
         * @return string
         */
        public function replaceParams($platform, $sql, array $params = null, array $types = null)
        {
                if (is_array($params)) {
                        foreach ($params as $key => $param) {
                                $type  = isset($types[$key]) ? $types[$key] : null; // Originally used null coalescing
                                $param = $this->convertParam($platform, $param, $type);
                                $sql   = preg_replace('/\?/', "$param", $sql, 1);
                        }
                }
                return $sql;
        }

        /**
         * Source at laravel-doctrine/orm LaravelDoctrine\ORM\Loggers\Formatters\ReplaceQueryParams::convertParam().
         *
         * @param mixed $param
         *
         * @throws \Exception
         * @return string
         */
        protected function convertParam($platform, $param, $type = null)
        {
                if (is_object($param)) {
                        if (!method_exists($param, '__toString')) {
                                if ($param instanceof \DateTimeInterface) {
                                        $param = $param->format('Y-m-d H:i:s');
                                } elseif (Type::hasType($type)) {
                                        $type  = Type::getType($type);
                                        $param = $type->convertToDatabaseValue($param, $platform);
                                } else {
                                        throw new \Exception('Given query param is an instance of ' . get_class($param) . ' and could not be converted to a string');
                                }
                        }
                } elseif (is_array($param)) {
                        if ($this->isNestedArray($param)) {
                                $param = json_encode($param, JSON_UNESCAPED_UNICODE);
                        } else {
                                $param = implode(
                                        ', ',
                                        array_map(
                                                function ($part) {
                                                        return '"' . (string) $part . '"';
                                                },
                                                $param
                                        )
                                );
                                return '(' . $param . ')';
                        }
                } else {
                        $param = htmlspecialchars((string) $param); // Originally used the e() Laravel helper
                }
                return '"' . (string) $param . '"';
        }

        /**
         * Source at laravel-doctrine/orm LaravelDoctrine\ORM\Loggers\Formatters\ReplaceQueryParams::isNestedArray().
         *
         * @param  array $array
         * @return bool
         */
        private function isNestedArray(array $array)
        {
                foreach ($array as $key => $value) {
                        if (is_array($value)) {
                                return true;
                        }
                }
                return false;
        }
}