sqltrackerquery.php

См. документацию.

<?php
 
namespace Bitrix\Main\Diag;
 
class SqlTrackerQuery implements \ArrayAccess
{
    protected $sql = "";
    protected $binds = null;
    protected $state = "";
    protected $node = "";
    protected $startTime = 0.0;
    protected $finishTime = 0.0;
    protected $time = 0.0;
    protected $trace = null;
    protected $tracker;
    protected int $lengths = 0;
    protected int $selectedRows = 0;
    protected int $fetchedRows = 0;
    protected int $selectedFieldsCount = 0;
    protected bool $hasBigFields = false;

    public function __construct(SqlTracker $tracker)
    {
        $this->tracker = $tracker;
    }

    public function startQuery($sql, array $binds = null)
    {
        $this->sql = $sql;
        $this->binds = $binds;
        $this->startTime = Helper::getCurrentMicrotime();
    }

    public function finishQuery($skip = 3)
    {
        $this->finishTime = Helper::getCurrentMicrotime();
        $this->time = $this->finishTime - $this->startTime;
        $this->trace = $this->filterTrace(Helper::getBackTrace($this->tracker->getDepthBackTrace(), null, $skip));
 
        $this->tracker->addTime($this->time);
        $this->tracker->writeFileLog($this->sql, $this->time, "", 4);
    }

    public function restartQuery()
    {
        $this->startTime = Helper::getCurrentMicrotime();
    }

    public function refinishQuery()
    {
        $this->finishTime = Helper::getCurrentMicrotime();
        $this->addTime($this->finishTime - $this->startTime);
    }

    public function addLength(int $length)
    {
            $this->lengths += $length;
    }

    public function getLength(): int
    {
        return $this->lengths;
    }

    public function incrementFetched(): void
    {
        $this->fetchedRows++;
    }

    public function getFetchedRowsCount(): int
    {
        return $this->fetchedRows;
    }

    public function setSelectedRowsCount(int $count): void
    {
        $this->selectedRows = $count;
    }

    public function getSelectedRowsCount(): int
    {
        return $this->selectedRows;
    }

    public function setSelectedFieldsCount(int $count): void
    {
        $this->selectedFieldsCount = $count;
    }

    public function getSelectedFieldsCount(): int
    {
        return $this->selectedFieldsCount;
    }
 
    public function setHasBigFields(bool $value)
    {
        $this->hasBigFields = $value;
    }
 
    public function hasBigFields(): bool
    {
        return $this->hasBigFields;
    }

    public function getSql()
    {
        return $this->sql;
    }

    public function setSql($sql)
    {
        $this->sql = (string)$sql;
        return $this;
    }

    public function getBinds()
    {
        return $this->binds;
    }

    public function setBinds(array $binds)
    {
        $this->binds = $binds;
        return $this;
    }

    public function getState()
    {
        return $this->state;
    }

    public function setState($state)
    {
        $this->state = (string)$state;
        return $this;
    }

    public function getNode()
    {
        return $this->node;
    }

    public function setNode($node)
    {
        $this->node = (string)$node;
        return $this;
    }

    public function getTime()
    {
        return $this->time;
    }

    public function setTime($time)
    {
        $this->tracker->addTime(-$this->time);
        $this->time = (float)$time;
        $this->tracker->addTime($this->time);
        return $this;
    }

    public function addTime($time)
    {
        $time = (float)$time;
        $this->time += $time;
        $this->tracker->addTime($time);
    }

    public function getTrace()
    {
        return $this->trace;
    }

    public function setTrace(array $trace = null)
    {
        $this->trace = ($trace !== null ? $this->filterTrace($trace) : []);
 
        return $this;
    }

    public function offsetExists($offset): bool
    {
        switch ((string)$offset)
        {
            case "BX_STATE":
            case "TIME":
            case "QUERY":
            case "TRACE":
            case "NODE_ID":
                return true;
            default:
                return false;
        }
    }

    #[\ReturnTypeWillChange]
    public function offsetGet($offset)
    {
        switch ($offset)
        {
            case "BX_STATE":
                return $this->state;
            case "TIME":
                return $this->time;
            case "QUERY":
                return $this->sql;
            case "TRACE":
                return $this->trace;
            case "NODE_ID":
                return $this->node;
            default:
                return false;
        }
    }

    public function offsetSet($offset, $value): void
    {
    }

    public function offsetUnset($offset): void
    {
    }

    protected function filterTrace($trace)
    {
        $filtered = array();
        foreach ($trace as $tr)
        {
            $args = array();
            if (!empty($tr["args"]) && is_array($tr["args"]))
            {
                foreach ($tr["args"] as $k1 => $v1)
                {
                    if (is_array($v1))
                    {
                        foreach ($v1 as $k2 => $v2)
                        {
                            if (is_scalar($v2))
                            {
                                $args[$k1][$k2] = $v2;
                            }
                            elseif (is_object($v2))
                            {
                                $args[$k1][$k2] = get_class($v2);
                            }
                            else
                            {
                                $args[$k1][$k2] = gettype($v2);
                            }
                        }
                    }
                    else
                    {
                        if (is_scalar($v1))
                        {
                            $args[$k1] = $v1;
                        }
                        elseif (is_object($v1))
                        {
                            $args[$k1] = get_class($v1);
                        }
                        else
                        {
                            $args[$k1] = gettype($v1);
                        }
                    }
                }
            }
 
            $filtered[] = [
                "file" => $tr["file"] ?? null,
                "line" => $tr["line"] ?? null,
                "class" => $tr["class"] ?? null,
                "type" => $tr["type"] ?? null,
                "function" => $tr["function"] ?? null,
                "args" => $args,
            ];
        }
        return $filtered;
    }
}