SelectFacade::query() - Code Metrics - lagdo/jaxon-dbadmin - Measure and Improve Code Quality continuously with Scrutinizer

SelectFacade::query() A
last analyzed 2025-12-22 05:57 UTC

↳ Parent: SelectFacade
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0
<?php

namespace Lagdo\DbAdmin\Db\Driver\Facades;

use Lagdo\DbAdmin\Db\Page\Dql\SelectEntity;
use Lagdo\DbAdmin\Db\Page\Dql\SelectQuery;
use Lagdo\DbAdmin\Db\Page\Dql\SelectResult;
use Lagdo\DbAdmin\Db\Service\TimerService;
use Exception;

use function count;

/**
 * Facade to table select functions
 */
class SelectFacade extends AbstractFacade
{
    /**
     * @var SelectQuery|null
     */
    private SelectQuery|null $selectQuery = null;

    /**
     * @var SelectResult|null
     */
    private SelectResult|null $selectResult = null;

    /**
     * @param AbstractFacade $dbFacade
     * @param TimerService $timer
     */
    public function __construct(AbstractFacade $dbFacade, protected TimerService $timer)
    {
        parent::__construct($dbFacade);
    }

    /**
     * @return SelectQuery
     */
    private function query(): SelectQuery
    {
        return $this->selectQuery ??= new SelectQuery($this->page, $this->driver, $this->utils);
        return $this->selectQuery ??= new SelectQuery($this->page, /** @scrutinizer ignore-type */ $this->driver, $this->utils);
    }

    /**
     * @return SelectResult
     */
    private function result(): SelectResult
    {
        return $this->selectResult ??= new SelectResult($this->page, $this->driver, $this->utils);
        return $this->selectResult ??= new SelectResult($this->page, /** @scrutinizer ignore-type */ $this->driver, $this->utils);
    }

    /**
     * @param string $table The table name
     * @param array $queryOptions The query options
     *
     * @return SelectEntity
     * @throws Exception
     */
    private function prepareSelect(string $table, array $queryOptions = []): SelectEntity
    {
        $tableStatus = $this->driver->tableStatusOrName($table);
        $tableStatus = $this->driver->tableStatusOrName($table);
        $tableName = $this->page->tableName($tableStatus);
        $selectEntity = new SelectEntity($table,
            $tableName, $tableStatus, $queryOptions);
        $this->query()->prepareSelect($selectEntity);

        return $selectEntity;
    }

    /**
     * Get required data for create/update on tables
     *
     * @param string $table The table name
     * @param array $queryOptions The query options
     *
     * @return SelectEntity
     * @throws Exception
     */
    public function getSelectData(string $table, array $queryOptions = []): SelectEntity
    {
        return $this->prepareSelect($table, $queryOptions);
    }

    /**
     * @param SelectEntity $selectEntity
     *
     * @return bool
     */
    private function hasGroupsInFields(SelectEntity $selectEntity): bool
    {
        return count($selectEntity->group) <
            count($selectEntity->select);
    }

    /**
     * Get required data for create/update on tables
     *
     * @param string $table The table name
     * @param array $queryOptions The query options
     *
     * @return int
     */
    public function countSelect(string $table, array $queryOptions): int
    {
        $selectEntity = $this->prepareSelect($table, $queryOptions);

        try {
            $query = $this->driver->getRowCountQuery($table,
                $selectEntity->where, $this->hasGroupsInFields($selectEntity),
                $selectEntity->group);
            return (int)$this->driver->result($query);
        } catch(Exception) {
            return -1;
        }
    }

    /**
     * @param SelectEntity $selectEntity
     *
     * @return void
     */
    private function executeQuery(SelectEntity $selectEntity): void
    {
        $this->timer->start();

        // From driver.inc.php
        $statement = $this->driver->execute($selectEntity->query);
        $selectEntity->duration = $this->timer->duration();
        $selectEntity->rows = [];

        // From adminer.inc.php
        if (!$statement) {
            $selectEntity->error = $this->driver->error();
            return;
        }

        // From select.inc.php
        $selectEntity->rows = [];
        while (($row = $statement->fetchAssoc())) {
            if ($selectEntity->page && $this->driver->jush() === "oracle") {
                unset($row["RNUM"]);
            }
            $selectEntity->rows[] = $row;
        }
    }

    /**
     * Get required data for create/update on tables
     *
     * @param string $table The table name
     * @param array $queryOptions The query options
     *
     * @return array
     * @throws Exception
     */
    public function execSelect(string $table, array $queryOptions): array
    {
        $selectEntity = $this->prepareSelect($table, $queryOptions);

        $this->executeQuery($selectEntity);

        if ($selectEntity->error !== null) {
            return [
                'message' => $selectEntity->error,
            ];
        }
        if (!$selectEntity->rows) {

            return [
                'message' => $this->utils->trans->lang('No rows.'),
            ];
        }

        // $backward_keys = $this->driver->backwardKeys($table, $tableName);
        // lengths = $this->getValuesLengths($rows, $selectEntity->queryOptions);

        $this->result()->setResultHeaders($selectEntity);

        return [
            'headers' => $selectEntity->headers,
            'query' => $selectEntity->query,
            'limit' => $selectEntity->limit,
            'duration' => $selectEntity->duration,
            'rows' => $this->result()->getRows($selectEntity),
        ];
    }
}

lagdo / jaxon-dbadmin

SelectFacade::query() A last analyzed 2025-12-22 05:57 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SelectFacade::query() A
last analyzed 2025-12-22 05:57 UTC
