AbstractQueryFactory::getColumnsList() - Code Metrics - thecodingmachine/tdbm - Measure and Improve Code Quality continuously with Scrutinizer

AbstractQueryFactory::getColumnsList() F
last analyzed 2025-10-27 09:28 UTC

↳ Parent: AbstractQueryFactory

Complexity

Conditions	20
Paths	372

Size

Total Lines	119
Code Lines	73

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	73
c	0
b	0
f	0
dl	0
loc	119
rs	1.1833
cc	20
nc	372
nop	4

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace TheCodingMachine\TDBM\QueryFactory;

use Doctrine\DBAL\Platforms\MySqlPlatform;
use Doctrine\DBAL\Schema\Schema;
use TheCodingMachine\TDBM\OrderByAnalyzer;
use TheCodingMachine\TDBM\TDBMInvalidArgumentException;
use TheCodingMachine\TDBM\TDBMService;
use TheCodingMachine\TDBM\UncheckedOrderBy;

use function array_unique;
use function in_array;

abstract class AbstractQueryFactory implements QueryFactory
{
    /**
     * @var TDBMService
     */
    protected $tdbmService;

    /**
     * @var Schema
     */
    protected $schema;

    /**
     * @var OrderByAnalyzer
     */
    protected $orderByAnalyzer;

    /**
     * @var string|UncheckedOrderBy|null
     */
    protected $orderBy;

    /**
     * @var string|null
     */
    protected $magicSql;
    /**
     * @var string|null
     */
    protected $magicSqlCount;
    /**
     * @var string|null
     */
    protected $magicSqlSubQuery;
    /** @var array<string, array<string, mixed>>|null */
    protected $columnDescList;
    /** @var array<int, array{table: string, column: string}>|null */
    protected $subQueryColumnDescList;
    /** @var string */
    protected $mainTable;

    /**
     * @param TDBMService $tdbmService
     * @param Schema $schema
     * @param OrderByAnalyzer $orderByAnalyzer
     * @param string|UncheckedOrderBy|null $orderBy
     */
    public function __construct(TDBMService $tdbmService, Schema $schema, OrderByAnalyzer $orderByAnalyzer, string $mainTable, $orderBy)
    {
        $this->tdbmService = $tdbmService;
        $this->schema = $schema;
        $this->orderByAnalyzer = $orderByAnalyzer;
        $this->orderBy = $orderBy;
        $this->mainTable = $mainTable;
    }

    /**
     * Returns the column list that must be fetched for the SQL request.
     *
     * Note: MySQL dictates that ORDER BYed columns should appear in the SELECT clause.
     *
     * @param string $mainTable
     * @param string[] $additionalTablesFetch
     * @param string|UncheckedOrderBy|null $orderBy
     *
     * @param bool $canAddAdditionalTablesFetch Set to true if the function can add additional tables to fetch (so if the factory generates its own FROM clause)
     * @return mixed[] A 3 elements array: [$columnDescList, $columnsList, $reconstructedOrderBy]
     */
    protected function getColumnsList(string $mainTable, array $additionalTablesFetch = array(), $orderBy = null, bool $canAddAdditionalTablesFetch = false): array
    {
        // From the table name and the additional tables we want to fetch, let's build a list of all tables
        // that must be part of the select columns.

        $connection = $this->tdbmService->getConnection();

        $tableGroups = [];
        $allFetchedTables = $this->tdbmService->_getRelatedTablesByInheritance($mainTable);
        $tableGroupName = $this->getTableGroupName($allFetchedTables);
        foreach ($allFetchedTables as $table) {
            $tableGroups[$table] = $tableGroupName;
        }

        $columnsList = [];
        $columnDescList = [];
        $sortColumn = 0;
        $reconstructedOrderBy = null;

        if (is_string($orderBy)) {
            $orderBy = trim($orderBy);
            if ($orderBy === '') {
                $orderBy = null;
            }
        }

        // Now, let's deal with "order by columns"
        if ($orderBy !== null) {
            $securedOrderBy = true;
            $reconstructedOrderBys = [];
            if ($orderBy instanceof UncheckedOrderBy) {
                $securedOrderBy = false;
                $orderBy = $orderBy->getOrderBy();
                $reconstructedOrderBy = $orderBy;
            }
            $orderByColumns = $this->orderByAnalyzer->analyzeOrderBy($orderBy);

            // If we sort by a column, there is a high chance we will fetch the bean containing this column.
            // Hence, we should add the table to the $additionalTablesFetch
            foreach ($orderByColumns as $orderByColumn) {
                if ($orderByColumn['type'] === 'colref') {
                    if ($orderByColumn['table'] !== null) {
                        if ($canAddAdditionalTablesFetch) {
                            $additionalTablesFetch[] = $orderByColumn['table'];
                        } else {
                            $sortColumnName = 'sort_column_'.$sortColumn;
                            $mysqlPlatform = new MySqlPlatform();
                            $columnsList[] = $mysqlPlatform->quoteIdentifier($orderByColumn['table']).'.'.$mysqlPlatform->quoteIdentifier($orderByColumn['column']).' as '.$sortColumnName;
                            $columnDescList[$sortColumnName] = [
                                'tableGroup' => null,
                            ];
                            ++$sortColumn;
                        }
                    }
                    if ($securedOrderBy) {
                        // Let's protect via MySQL since we go through MagicJoin
                        $mysqlPlatform = new MySqlPlatform();
                        $reconstructedOrderBys[] = ($orderByColumn['table'] !== null ? $mysqlPlatform->quoteIdentifier($orderByColumn['table']).'.' : '').$mysqlPlatform->quoteIdentifier($orderByColumn['column']).' '.$orderByColumn['direction'];
                    }
                } elseif ($orderByColumn['type'] === 'expr') {
                    $sortColumnName = 'sort_column_'.$sortColumn;
                    $columnsList[] = $orderByColumn['expr'].' as '.$connection->quoteIdentifier($sortColumnName);
                    $columnDescList[$sortColumnName] = [
                        'tableGroup' => null,
                    ];
                    ++$sortColumn;

                    if ($securedOrderBy) {
                        throw new TDBMInvalidArgumentException('Invalid ORDER BY column: "'.$orderByColumn['expr'].'". If you want to use expression in your ORDER BY clause, you must wrap them in a UncheckedOrderBy object. For instance: new UncheckedOrderBy("col1 + col2 DESC")');
                    }
                }
            }

            if ($reconstructedOrderBy === null) {
                $reconstructedOrderBy = implode(', ', $reconstructedOrderBys);
            }
        }

        foreach ($additionalTablesFetch as $additionalTable) {
            if (in_array($additionalTable, $allFetchedTables, true)) {
                continue;
            }

            $relatedTables = $this->tdbmService->_getRelatedTablesByInheritance($additionalTable);
            $tableGroupName = $this->getTableGroupName($relatedTables);
            foreach ($relatedTables as $table) {
                $tableGroups[$table] = $tableGroupName;
            }
            $allFetchedTables = array_merge($allFetchedTables, $relatedTables);
        }

        // Let's remove any duplicate
        $allFetchedTables = array_unique($allFetchedTables);

        // We quote in MySQL because MagicJoin requires MySQL style quotes
        $mysqlPlatform = new MySqlPlatform();

        // Now, let's build the column list
        foreach ($allFetchedTables as $table) {
            foreach ($this->schema->getTable($table)->getColumns() as $column) {
                $columnName = $column->getName();
                $alias = self::getColumnAlias($table, $columnName);
                $columnDescList[$alias] = [
                    'as' => $alias,
                    'table' => $table,
                    'column' => $columnName,
                    'type' => $column->getType(),
                    'tableGroup' => $tableGroups[$table],
                ];
                $columnsList[] = sprintf(
                    '%s.%s as %s',
                    $mysqlPlatform->quoteIdentifier($table),
                    $mysqlPlatform->quoteIdentifier($columnName),
                    $connection->quoteIdentifier($alias)
                );
            }
        }

        return [$columnDescList, $columnsList, $reconstructedOrderBy];
    }

    public static function getColumnAlias(string $tableName, string $columnName): string
    {
        $alias = $tableName.'____'.$columnName;
        if (strlen($alias) <= 30) { // Older oracle version had a limit of 30 characters for identifiers
            return $alias;
        }
        return substr($columnName, 0, 20) . crc32($tableName.'____'.$columnName);
    }

    abstract protected function compute(): void;

    /**
     * Returns an identifier for the group of tables passed in parameter.
     *
     * @param string[] $relatedTables
     *
     * @return string
     */
    protected function getTableGroupName(array $relatedTables): string
    {
        sort($relatedTables);

        return implode('_``_', $relatedTables);
    }

    public function getMagicSql(): string
    {
        if ($this->magicSql === null) {
            $this->compute();
        }

        return $this->magicSql;

    }

    public function getMagicSqlCount(): string
    {
        if ($this->magicSqlCount === null) {
            $this->compute();
        }

        return $this->magicSqlCount;

    }

    public function getMagicSqlSubQuery(): string
    {
        if ($this->magicSqlSubQuery === null) {
            $this->compute();
        }

        return $this->magicSqlSubQuery;

    }

    public function getColumnDescriptors(): array
    {
        if ($this->columnDescList === null) {
            $this->compute();
        }

        return $this->columnDescList;

    }

    /**
     * @return array<int, array{table: string, column: string}> An array of column descriptors.
     */
    public function getSubQueryColumnDescriptors(): array
    {
        if ($this->subQueryColumnDescList === null) {
            $columns = $this->tdbmService->getPrimaryKeyColumns($this->mainTable);
            $descriptors = [];
            foreach ($columns as $column) {
                $descriptors[] = [
                    'table' => $this->mainTable,
                    'column' => $column
                ];
            }
            $this->subQueryColumnDescList = $descriptors;
        }

        return $this->subQueryColumnDescList;
    }


    /**
     * Sets the ORDER BY directive executed in SQL.
     *
     * For instance:
     *
     *  $queryFactory->sort('label ASC, status DESC');
     *
     * **Important:** TDBM does its best to protect you from SQL injection. In particular, it will only allow column names in the "ORDER BY" clause. This means you are safe to pass input from the user directly in the ORDER BY parameter.
     * If you want to pass an expression to the ORDER BY clause, you will need to tell TDBM to stop checking for SQL injections. You do this by passing a `UncheckedOrderBy` object as a parameter:
     *
     *  $queryFactory->sort(new UncheckedOrderBy('RAND()'))
     *
     * @param string|UncheckedOrderBy|null $orderBy
     */
    public function sort($orderBy): void
    {
        $this->orderBy = $orderBy;
        $this->magicSql = null;
        $this->magicSqlCount = null;
        $this->columnDescList = null;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace TheCodingMachine\TDBM\QueryFactory;
6
7			use Doctrine\DBAL\Platforms\MySqlPlatform;
8			use Doctrine\DBAL\Schema\Schema;
9			use TheCodingMachine\TDBM\OrderByAnalyzer;
10			use TheCodingMachine\TDBM\TDBMInvalidArgumentException;
11			use TheCodingMachine\TDBM\TDBMService;
12			use TheCodingMachine\TDBM\UncheckedOrderBy;
13
14			use function array_unique;
15			use function in_array;
16
17			abstract class AbstractQueryFactory implements QueryFactory
18			{
19			/**
20			* @var TDBMService
21			*/
22			protected $tdbmService;
23
24			/**
25			* @var Schema
26			*/
27			protected $schema;
28
29			/**
30			* @var OrderByAnalyzer
31			*/
32			protected $orderByAnalyzer;
33
34			/**
35			* @var string\|UncheckedOrderBy\|null
36			*/
37			protected $orderBy;
38
39			/**
40			* @var string\|null
41			*/
42			protected $magicSql;
43			/**
44			* @var string\|null
45			*/
46			protected $magicSqlCount;
47			/**
48			* @var string\|null
49			*/
50			protected $magicSqlSubQuery;
51			/** @var array<string, array<string, mixed>>\|null */
52			protected $columnDescList;
53			/** @var array<int, array{table: string, column: string}>\|null */
54			protected $subQueryColumnDescList;
55			/** @var string */
56			protected $mainTable;
57
58			/**
59			* @param TDBMService $tdbmService
60			* @param Schema $schema
61			* @param OrderByAnalyzer $orderByAnalyzer
62			* @param string\|UncheckedOrderBy\|null $orderBy
63			*/
64			public function __construct(TDBMService $tdbmService, Schema $schema, OrderByAnalyzer $orderByAnalyzer, string $mainTable, $orderBy)
65			{
66			$this->tdbmService = $tdbmService;
67			$this->schema = $schema;
68			$this->orderByAnalyzer = $orderByAnalyzer;
69			$this->orderBy = $orderBy;
70			$this->mainTable = $mainTable;
71			}
72
73			/**
74			* Returns the column list that must be fetched for the SQL request.
75			*
76			* Note: MySQL dictates that ORDER BYed columns should appear in the SELECT clause.
77			*
78			* @param string $mainTable
79			* @param string[] $additionalTablesFetch
80			* @param string\|UncheckedOrderBy\|null $orderBy
81			*
82			* @param bool $canAddAdditionalTablesFetch Set to true if the function can add additional tables to fetch (so if the factory generates its own FROM clause)
83			* @return mixed[] A 3 elements array: [$columnDescList, $columnsList, $reconstructedOrderBy]
84			*/
85			protected function getColumnsList(string $mainTable, array $additionalTablesFetch = array(), $orderBy = null, bool $canAddAdditionalTablesFetch = false): array
86			{
87			// From the table name and the additional tables we want to fetch, let's build a list of all tables
88			// that must be part of the select columns.
89
90			$connection = $this->tdbmService->getConnection();
91
92			$tableGroups = [];
93			$allFetchedTables = $this->tdbmService->_getRelatedTablesByInheritance($mainTable);
94			$tableGroupName = $this->getTableGroupName($allFetchedTables);
95			foreach ($allFetchedTables as $table) {
96			$tableGroups[$table] = $tableGroupName;
97			}
98
99			$columnsList = [];
100			$columnDescList = [];
101			$sortColumn = 0;
102			$reconstructedOrderBy = null;
103
104			if (is_string($orderBy)) {
105			$orderBy = trim($orderBy);
106			if ($orderBy === '') {
107			$orderBy = null;
108			}
109			}
110
111			// Now, let's deal with "order by columns"
112			if ($orderBy !== null) {
113			$securedOrderBy = true;
114			$reconstructedOrderBys = [];
115			if ($orderBy instanceof UncheckedOrderBy) {
116			$securedOrderBy = false;
117			$orderBy = $orderBy->getOrderBy();
118			$reconstructedOrderBy = $orderBy;
119			}
120			$orderByColumns = $this->orderByAnalyzer->analyzeOrderBy($orderBy);
121
122			// If we sort by a column, there is a high chance we will fetch the bean containing this column.
123			// Hence, we should add the table to the $additionalTablesFetch
124			foreach ($orderByColumns as $orderByColumn) {
125			if ($orderByColumn['type'] === 'colref') {
126			if ($orderByColumn['table'] !== null) {
127			if ($canAddAdditionalTablesFetch) {
128			$additionalTablesFetch[] = $orderByColumn['table'];
129			} else {
130			$sortColumnName = 'sort_column_'.$sortColumn;
131			$mysqlPlatform = new MySqlPlatform();
132			$columnsList[] = $mysqlPlatform->quoteIdentifier($orderByColumn['table']).'.'.$mysqlPlatform->quoteIdentifier($orderByColumn['column']).' as '.$sortColumnName;
133			$columnDescList[$sortColumnName] = [
134			'tableGroup' => null,
135			];
136			++$sortColumn;
137			}
138			}
139			if ($securedOrderBy) {
140			// Let's protect via MySQL since we go through MagicJoin
141			$mysqlPlatform = new MySqlPlatform();
142			$reconstructedOrderBys[] = ($orderByColumn['table'] !== null ? $mysqlPlatform->quoteIdentifier($orderByColumn['table']).'.' : '').$mysqlPlatform->quoteIdentifier($orderByColumn['column']).' '.$orderByColumn['direction'];
143			}
144			} elseif ($orderByColumn['type'] === 'expr') {
145			$sortColumnName = 'sort_column_'.$sortColumn;
146			$columnsList[] = $orderByColumn['expr'].' as '.$connection->quoteIdentifier($sortColumnName);
147			$columnDescList[$sortColumnName] = [
148			'tableGroup' => null,
149			];
150			++$sortColumn;
151
152			if ($securedOrderBy) {
153			throw new TDBMInvalidArgumentException('Invalid ORDER BY column: "'.$orderByColumn['expr'].'". If you want to use expression in your ORDER BY clause, you must wrap them in a UncheckedOrderBy object. For instance: new UncheckedOrderBy("col1 + col2 DESC")');
154			}
155			}
156			}
157
158			if ($reconstructedOrderBy === null) {
159			$reconstructedOrderBy = implode(', ', $reconstructedOrderBys);
160			}
161			}
162
163			foreach ($additionalTablesFetch as $additionalTable) {
164			if (in_array($additionalTable, $allFetchedTables, true)) {
165			continue;
166			}
167
168			$relatedTables = $this->tdbmService->_getRelatedTablesByInheritance($additionalTable);
169			$tableGroupName = $this->getTableGroupName($relatedTables);
170			foreach ($relatedTables as $table) {
171			$tableGroups[$table] = $tableGroupName;
172			}
173			$allFetchedTables = array_merge($allFetchedTables, $relatedTables);
174			}
175
176			// Let's remove any duplicate
177			$allFetchedTables = array_unique($allFetchedTables);
178
179			// We quote in MySQL because MagicJoin requires MySQL style quotes
180			$mysqlPlatform = new MySqlPlatform();
181
182			// Now, let's build the column list
183			foreach ($allFetchedTables as $table) {
184			foreach ($this->schema->getTable($table)->getColumns() as $column) {
185			$columnName = $column->getName();
186			$alias = self::getColumnAlias($table, $columnName);
187			$columnDescList[$alias] = [
188			'as' => $alias,
189			'table' => $table,
190			'column' => $columnName,
191			'type' => $column->getType(),
192			'tableGroup' => $tableGroups[$table],
193			];
194			$columnsList[] = sprintf(
195			'%s.%s as %s',
196			$mysqlPlatform->quoteIdentifier($table),
197			$mysqlPlatform->quoteIdentifier($columnName),
198			$connection->quoteIdentifier($alias)
199			);
200			}
201			}
202
203			return [$columnDescList, $columnsList, $reconstructedOrderBy];
204			}
205
206			public static function getColumnAlias(string $tableName, string $columnName): string
207			{
208			$alias = $tableName.'____'.$columnName;
209			if (strlen($alias) <= 30) { // Older oracle version had a limit of 30 characters for identifiers
210			return $alias;
211			}
212			return substr($columnName, 0, 20) . crc32($tableName.'____'.$columnName);
213			}
214
215			abstract protected function compute(): void;
216
217			/**
218			* Returns an identifier for the group of tables passed in parameter.
219			*
220			* @param string[] $relatedTables
221			*
222			* @return string
223			*/
224			protected function getTableGroupName(array $relatedTables): string
225			{
226			sort($relatedTables);
227
228			return implode('_``_', $relatedTables);
229			}
230
231			public function getMagicSql(): string
232			{
233			if ($this->magicSql === null) {
234			$this->compute();
235			}
236
237			return $this->magicSql;
			0 ignored issues – show Bug Best Practice introduced 2019-08-16 13:58 UTC by Report Bug Copy Issue Report The expression `return $this->magicSql` could return the type `null` which is incompatible with the type-hinted return `string`. Consider adding an additional type-check to rule them out. Loading history...
238			}
239
240			public function getMagicSqlCount(): string
241			{
242			if ($this->magicSqlCount === null) {
243			$this->compute();
244			}
245
246			return $this->magicSqlCount;
			0 ignored issues – show Bug Best Practice introduced 2019-08-16 13:58 UTC by Report Bug Copy Issue Report The expression `return $this->magicSqlCount` could return the type `null` which is incompatible with the type-hinted return `string`. Consider adding an additional type-check to rule them out. Loading history...
247			}
248
249			public function getMagicSqlSubQuery(): string
250			{
251			if ($this->magicSqlSubQuery === null) {
252			$this->compute();
253			}
254
255			return $this->magicSqlSubQuery;
			0 ignored issues – show Bug Best Practice introduced 2019-08-16 13:58 UTC by Report Bug Copy Issue Report The expression `return $this->magicSqlSubQuery` could return the type `null` which is incompatible with the type-hinted return `string`. Consider adding an additional type-check to rule them out. Loading history...
256			}
257
258			public function getColumnDescriptors(): array
259			{
260			if ($this->columnDescList === null) {
261			$this->compute();
262			}
263
264			return $this->columnDescList;
			0 ignored issues – show Bug Best Practice introduced 2021-03-18 14:30 UTC by Report Bug Copy Issue Report The expression `return $this->columnDescList` could return the type `null` which is incompatible with the type-hinted return `array`. Consider adding an additional type-check to rule them out. Loading history...
265			}
266
267			/**
268			* @return array<int, array{table: string, column: string}> An array of column descriptors.
269			*/
270			public function getSubQueryColumnDescriptors(): array
271			{
272			if ($this->subQueryColumnDescList === null) {
273			$columns = $this->tdbmService->getPrimaryKeyColumns($this->mainTable);
274			$descriptors = [];
275			foreach ($columns as $column) {
276			$descriptors[] = [
277			'table' => $this->mainTable,
278			'column' => $column
279			];
280			}
281			$this->subQueryColumnDescList = $descriptors;
282			}
283
284			return $this->subQueryColumnDescList;
285			}
286
287
288			/**
289			* Sets the ORDER BY directive executed in SQL.
290			*
291			* For instance:
292			*
293			* $queryFactory->sort('label ASC, status DESC');
294			*
295			* Important: TDBM does its best to protect you from SQL injection. In particular, it will only allow column names in the "ORDER BY" clause. This means you are safe to pass input from the user directly in the ORDER BY parameter.
296			* If you want to pass an expression to the ORDER BY clause, you will need to tell TDBM to stop checking for SQL injections. You do this by passing a `UncheckedOrderBy` object as a parameter:
297			*
298			* $queryFactory->sort(new UncheckedOrderBy('RAND()'))
299			*
300			* @param string\|UncheckedOrderBy\|null $orderBy
301			*/
302			public function sort($orderBy): void
303			{
304			$this->orderBy = $orderBy;
305			$this->magicSql = null;
306			$this->magicSqlCount = null;
307			$this->columnDescList = null;
308			}
309			}
310

thecodingmachine / tdbm

AbstractQueryFactory::getColumnsList() F last analyzed 2025-10-27 09:28 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

AbstractQueryFactory::getColumnsList() F
last analyzed 2025-10-27 09:28 UTC