40847823331

Committed 29 Oct 2026 09:12AM UTC coverage: 93.52% (+0.3%) from 93.219%

Build # 40847823331

Build Type

Pull #22

github

Committed by

web-flow

Commit Message

Merge a6b38eda7 into 3fe444e81

Pull Request Pull Request #22: Release 6.0: PHP 8.5 standalone core and CodeIgniter 4 adapter

Coverage Stats

435 of 468 new or added lines in 23 files covered. (92.95%)

967 of 1034 relevant lines covered (93.52%)

25.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.43

/src/Logging/QueryMiddleware.php

<?php

declare(strict_types=1);

namespace Daycry\Doctrine\Logging;

use Closure;
use Doctrine\DBAL\Driver;
use Doctrine\DBAL\Driver\Connection;
use Doctrine\DBAL\Driver\Middleware;
use Doctrine\DBAL\Driver\Middleware\AbstractConnectionMiddleware;
use Doctrine\DBAL\Driver\Middleware\AbstractDriverMiddleware;
use Doctrine\DBAL\Driver\Middleware\AbstractStatementMiddleware;
use Doctrine\DBAL\Driver\Result;
use Doctrine\DBAL\Driver\Statement;
use Doctrine\DBAL\ParameterType;

/**
 * Shared instrumentation for successful DBAL queries.
 */
abstract class QueryMiddleware implements Middleware
{
    /**
     * @param array<int|string, mixed> $params
     */
    abstract protected function onQuery(string $sql, array $params, float $start, float $duration): void;

    public function wrap(Driver $driver): Driver
    {
        return new class ($driver, $this->onQuery(...)) extends AbstractDriverMiddleware {
            public function __construct(Driver $driver, private readonly Closure $record)
            {
                parent::__construct($driver);
            }

            public function connect(array $params): Connection
            {
                return new class (parent::connect($params), $this->record) extends AbstractConnectionMiddleware {
                    public function __construct(private readonly Connection $connection, private readonly Closure $record)
                    {
                        parent::__construct($connection);
                    }

                    public function prepare(string $sql): Statement
                    {
                        return new class (parent::prepare($sql), $sql, $this->record) extends AbstractStatementMiddleware {
                            /**
                             * @var array<int|string, mixed>
                             */
                            private array $params = [];

                            public function __construct(Statement $statement, private readonly string $sql, private readonly Closure $record)
                            {
                                parent::__construct($statement);
                            }

                            public function bindValue(int|string $param, mixed $value, ParameterType $type): void
                            {
                                parent::bindValue($param, $value, $type);
                                $this->params[$param] = $value;
                            }

                            public function execute(): Result
                            {
                                $start  = microtime(true);
                                $timer  = hrtime(true);
                                $result = parent::execute();
                                ($this->record)($this->sql, $this->params, $start, (float) (hrtime(true) - $timer) / 1e9);

                                return $result;
                            }
                        };
                    }

                    public function query(string $sql): Result
                    {
                        $start  = microtime(true);
                        $timer  = hrtime(true);
                        $result = parent::query($sql);
                        ($this->record)($sql, [], $start, (float) (hrtime(true) - $timer) / 1e9);

                        return $result;
                    }

                    public function exec(string $sql): int|string
                    {
                        $start  = microtime(true);
                        $timer  = hrtime(true);
                        $result = parent::exec($sql);
                        ($this->record)($sql, [], $start, (float) (hrtime(true) - $timer) / 1e9);

                        return $result;
                    }

                    /**
                     * @param array<int|string, mixed> $arguments
                     */
                    public function __call(string $name, array $arguments): mixed
                    {
                        return $this->connection->{$name}(...$arguments);
                    }
                };
            }
        };
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Daycry\Doctrine\Logging;
6
7	use Closure;
8	use Doctrine\DBAL\Driver;
9	use Doctrine\DBAL\Driver\Connection;
10	use Doctrine\DBAL\Driver\Middleware;
11	use Doctrine\DBAL\Driver\Middleware\AbstractConnectionMiddleware;
12	use Doctrine\DBAL\Driver\Middleware\AbstractDriverMiddleware;
13	use Doctrine\DBAL\Driver\Middleware\AbstractStatementMiddleware;
14	use Doctrine\DBAL\Driver\Result;
15	use Doctrine\DBAL\Driver\Statement;
16	use Doctrine\DBAL\ParameterType;
17
18	/**
19	* Shared instrumentation for successful DBAL queries.
20	*/
21	abstract class QueryMiddleware implements Middleware
22	{
23	/**
24	* @param array<int\|string, mixed> $params
25	*/
26	abstract protected function onQuery(string $sql, array $params, float $start, float $duration): void;
27
28	public function wrap(Driver $driver): Driver	135 ✔
29	{
30	return new class ($driver, $this->onQuery(...)) extends AbstractDriverMiddleware {	135 ✔
31	public function __construct(Driver $driver, private readonly Closure $record)
32	{
33	parent::__construct($driver);	135 ✔
34	}
35
36	public function connect(array $params): Connection
37	{
38	return new class (parent::connect($params), $this->record) extends AbstractConnectionMiddleware {	90 ✔
39	public function __construct(private readonly Connection $connection, private readonly Closure $record)
40	{
41	parent::__construct($connection);	90 ✔
42	}
43
44	public function prepare(string $sql): Statement
45	{
46	return new class (parent::prepare($sql), $sql, $this->record) extends AbstractStatementMiddleware {	42 ✔
47	/**
48	* @var array<int\|string, mixed>
49	*/
50	private array $params = [];
51
52	public function __construct(Statement $statement, private readonly string $sql, private readonly Closure $record)
53	{
54	parent::__construct($statement);	42 ✔
55	}
56
57	public function bindValue(int\|string $param, mixed $value, ParameterType $type): void
58	{
59	parent::bindValue($param, $value, $type);	42 ✔
60	$this->params[$param] = $value;	42 ✔
61	}
62
63	public function execute(): Result
64	{
65	$start = microtime(true);	42 ✔
66	$timer = hrtime(true);	42 ✔
67	$result = parent::execute();	42 ✔
68	($this->record)($this->sql, $this->params, $start, (float) (hrtime(true) - $timer) / 1e9);	42 ✔
69
70	return $result;	42 ✔
71	}
72	};	42 ✔
73	}
74
75	public function query(string $sql): Result
76	{
77	$start = microtime(true);	52 ✔
78	$timer = hrtime(true);	52 ✔
79	$result = parent::query($sql);	52 ✔
80	($this->record)($sql, [], $start, (float) (hrtime(true) - $timer) / 1e9);	50 ✔
81
82	return $result;	50 ✔
83	}
84
85	public function exec(string $sql): int\|string
86	{
87	$start = microtime(true);	25 ✔
88	$timer = hrtime(true);	25 ✔
89	$result = parent::exec($sql);	25 ✔
90	($this->record)($sql, [], $start, (float) (hrtime(true) - $timer) / 1e9);	25 ✔
91
92	return $result;	25 ✔
93	}
94
95	/**
96	* @param array<int\|string, mixed> $arguments
97	*/
98	public function __call(string $name, array $arguments): mixed
99	{
NEW 100	return $this->connection->{$name}(...$arguments);	×
101	}
102	};	90 ✔
103	}
104	};	135 ✔
105	}
106	}

daycry / doctrine / 40847823331

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous