GrammarTrait::buildSelectQuery() - Code Metrics - lagdo/dbadmin-driver - Measure and Improve Code Quality continuously with Scrutinizer

GrammarTrait::buildSelectQuery() A
last analyzed 2025-08-14 05:53 UTC

↳ Parent: GrammarTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Lagdo\DbAdmin\Driver;

use Lagdo\DbAdmin\Driver\Db\GrammarInterface;
use Lagdo\DbAdmin\Driver\Entity\TableFieldEntity;
use Lagdo\DbAdmin\Driver\Entity\TableSelectEntity;
use Lagdo\DbAdmin\Driver\Entity\ForeignKeyEntity;
use Lagdo\DbAdmin\Driver\Entity\QueryEntity;

trait GrammarTrait
{
    /**
     * @var GrammarInterface
     */
    protected $grammar;

    /**
     * Get escaped table name
     *
     * @param string $idf
     *
     * @return string
     */
    public function escapeTableName(string $idf)
    {
        return $this->grammar->escapeTableName($idf);
    }

    /**
     * Escape database identifier
     *
     * @param string $idf
     *
     * @return string
     */
    public function escapeId(string $idf)
    {
        return $this->grammar->escapeId($idf);
    }

    /**
     * Unescape database identifier
     *
     * @param string $idf
     *
     * @return string
     */
    public function unescapeId(string $idf)
    {
        return $this->grammar->unescapeId($idf);
    }

    /**
     * Convert field in select and edit
     *
     * @param TableFieldEntity $field one element from $this->fields()
     *
     * @return string
     */
    public function convertField(TableFieldEntity $field)
    {
        return $this->grammar->convertField($field);
    }

    /**
     * Convert value in edit after applying functions back
     *
     * @param TableFieldEntity $field One element from $this->fields()
     * @param string $value
     *
     * @return string
     */
    public function unconvertField(TableFieldEntity $field, string $value)
    {
        return $this->grammar->unconvertField($field, $value);
    }

    /**
     * Get select clause for convertible fields
     *
     * @param array $columns
     * @param array $fields
     * @param array $select
     *
     * @return string
     */
    public function convertFields(array $columns, array $fields, array $select = [])
    {
        return $this->grammar->convertFields($columns, $fields, $select);
    }

    /**
     * Select data from table
     *
     * @param TableSelectEntity $select
     *
     * @return string
     */
    public function buildSelectQuery(TableSelectEntity $select)
    {
        return $this->grammar->buildSelectQuery($select);
    }

    /**
     * Parse a string containing SQL queries
     *
     * @param QueryEntity $queryEntity
     *
     * @return bool
     */
    public function parseQueries(QueryEntity $queryEntity)
    {
        return $this->grammar->parseQueries($queryEntity);
    }

    /**
     * Get query to compute number of found rows
     *
     * @param string $table
     * @param array $where
     * @param bool $isGroup
     * @param array $groups
     *
     * @return string
     */
    public function getRowCountQuery(string $table, array $where, bool $isGroup, array $groups)
    {
        return $this->grammar->getRowCountQuery($table, $where, $isGroup, $groups);
    }

    /**
     * Get default value clause
     *
     * @param TableFieldEntity $field
     *
     * @return string
     */
    public function getDefaultValueClause(TableFieldEntity $field)
    {
        return $this->grammar->getDefaultValueClause($field);
    }

    /**
     * Formulate SQL query with limit
     *
     * @param string $query Everything after SELECT
     * @param string $where Including WHERE
     * @param int $limit
     * @param int $offset
     *
     * @return string
     */
    public function getLimitClause(string $query, string $where, int $limit, int $offset = 0)
    {
        return $this->grammar->getLimitClause($query, $where, $limit, $offset);
    }

    /**
     * Format foreign key to use in SQL query
     *
     * @param ForeignKeyEntity $foreignKey
     *
     * @return string
     */
    public function formatForeignKey(ForeignKeyEntity $foreignKey)
    {
        return $this->grammar->formatForeignKey($foreignKey);
    }

    /**
     * Generate modifier for auto increment column
     *
     * @return string
     */
    public function getAutoIncrementModifier()
    {
        return $this->grammar->getAutoIncrementModifier();
    }

    /**
     * Get SQL command to create table
     *
     * @param string $table
     * @param bool $autoIncrement
     * @param string $style
     *
     * @return string
     */
    public function getCreateTableQuery(string $table, bool $autoIncrement, string $style)
    {
        return $this->grammar->getCreateTableQuery($table, $autoIncrement, $style);
    }

    /**
     * Command to create an index
     *
     * @param string $table
     * @param string $type
     * @param string $name
     * @param string $columns
     *
     * @return string
     */
    public function getCreateIndexQuery(string $table, string $type, string $name, string $columns)
    {
        return $this->grammar->getCreateIndexQuery($table, $type, $name, $columns);
    }

    /**
     * Get SQL command to create foreign keys
     *
     * getCreateTableQuery() produces CREATE TABLE without FK CONSTRAINTs
     * getForeignKeysQuery() produces all FK CONSTRAINTs as ALTER TABLE ... ADD CONSTRAINT
     * so that all FKs can be added after all tables have been created, avoiding any need
     * to reorder CREATE TABLE statements in order of their FK dependencies
     *
     * @param string $table
     *
     * @return string
     */
    public function getForeignKeysQuery(string $table)
    {
        return $this->grammar->getForeignKeysQuery($table);
    }

    /**
     * Get SQL command to truncate table
     *
     * @param string $table
     *
     * @return string
     */
    public function getTruncateTableQuery(string $table)
    {
        return $this->grammar->getTruncateTableQuery($table);
    }

    /**
     * Get SQL command to change database
     *
     * @param string $database
     *
     * @return string
     */
    public function getUseDatabaseQuery(string $database)
    {
        return $this->grammar->getUseDatabaseQuery($database);
    }

    /**
     * Get SQL commands to create triggers
     *
     * @param string $table
     *
     * @return string
     */
    public function getCreateTriggerQuery(string $table)
    {
        return $this->grammar->getCreateTriggerQuery($table);
    }

    /**
     * Return query to get connection ID
     *
     * @return string
     */
    // public function connectionId()
    // {
    //     return $this->grammar->connectionId();
    // }
}


1			<?php
2
3			namespace Lagdo\DbAdmin\Driver;
4
5			use Lagdo\DbAdmin\Driver\Db\GrammarInterface;
6			use Lagdo\DbAdmin\Driver\Entity\TableFieldEntity;
7			use Lagdo\DbAdmin\Driver\Entity\TableSelectEntity;
8			use Lagdo\DbAdmin\Driver\Entity\ForeignKeyEntity;
9			use Lagdo\DbAdmin\Driver\Entity\QueryEntity;
10
11			trait GrammarTrait
12			{
13			/**
14			* @var GrammarInterface
15			*/
16			protected $grammar;
17
18			/**
19			* Get escaped table name
20			*
21			* @param string $idf
22			*
23			* @return string
24			*/
25			public function escapeTableName(string $idf)
26			{
27			return $this->grammar->escapeTableName($idf);
28			}
29
30			/**
31			* Escape database identifier
32			*
33			* @param string $idf
34			*
35			* @return string
36			*/
37			public function escapeId(string $idf)
38			{
39			return $this->grammar->escapeId($idf);
40			}
41
42			/**
43			* Unescape database identifier
44			*
45			* @param string $idf
46			*
47			* @return string
48			*/
49			public function unescapeId(string $idf)
50			{
51			return $this->grammar->unescapeId($idf);
52			}
53
54			/**
55			* Convert field in select and edit
56			*
57			* @param TableFieldEntity $field one element from $this->fields()
58			*
59			* @return string
60			*/
61			public function convertField(TableFieldEntity $field)
62			{
63			return $this->grammar->convertField($field);
64			}
65
66			/**
67			* Convert value in edit after applying functions back
68			*
69			* @param TableFieldEntity $field One element from $this->fields()
70			* @param string $value
71			*
72			* @return string
73			*/
74			public function unconvertField(TableFieldEntity $field, string $value)
75			{
76			return $this->grammar->unconvertField($field, $value);
77			}
78
79			/**
80			* Get select clause for convertible fields
81			*
82			* @param array $columns
83			* @param array $fields
84			* @param array $select
85			*
86			* @return string
87			*/
88			public function convertFields(array $columns, array $fields, array $select = [])
89			{
90			return $this->grammar->convertFields($columns, $fields, $select);
91			}
92
93			/**
94			* Select data from table
95			*
96			* @param TableSelectEntity $select
97			*
98			* @return string
99			*/
100			public function buildSelectQuery(TableSelectEntity $select)
101			{
102			return $this->grammar->buildSelectQuery($select);
103			}
104
105			/**
106			* Parse a string containing SQL queries
107			*
108			* @param QueryEntity $queryEntity
109			*
110			* @return bool
111			*/
112			public function parseQueries(QueryEntity $queryEntity)
113			{
114			return $this->grammar->parseQueries($queryEntity);
115			}
116
117			/**
118			* Get query to compute number of found rows
119			*
120			* @param string $table
121			* @param array $where
122			* @param bool $isGroup
123			* @param array $groups
124			*
125			* @return string
126			*/
127			public function getRowCountQuery(string $table, array $where, bool $isGroup, array $groups)
128			{
129			return $this->grammar->getRowCountQuery($table, $where, $isGroup, $groups);
130			}
131
132			/**
133			* Get default value clause
134			*
135			* @param TableFieldEntity $field
136			*
137			* @return string
138			*/
139			public function getDefaultValueClause(TableFieldEntity $field)
140			{
141			return $this->grammar->getDefaultValueClause($field);
142			}
143
144			/**
145			* Formulate SQL query with limit
146			*
147			* @param string $query Everything after SELECT
148			* @param string $where Including WHERE
149			* @param int $limit
150			* @param int $offset
151			*
152			* @return string
153			*/
154			public function getLimitClause(string $query, string $where, int $limit, int $offset = 0)
155			{
156			return $this->grammar->getLimitClause($query, $where, $limit, $offset);
157			}
158
159			/**
160			* Format foreign key to use in SQL query
161			*
162			* @param ForeignKeyEntity $foreignKey
163			*
164			* @return string
165			*/
166			public function formatForeignKey(ForeignKeyEntity $foreignKey)
167			{
168			return $this->grammar->formatForeignKey($foreignKey);
169			}
170
171			/**
172			* Generate modifier for auto increment column
173			*
174			* @return string
175			*/
176			public function getAutoIncrementModifier()
177			{
178			return $this->grammar->getAutoIncrementModifier();
179			}
180
181			/**
182			* Get SQL command to create table
183			*
184			* @param string $table
185			* @param bool $autoIncrement
186			* @param string $style
187			*
188			* @return string
189			*/
190			public function getCreateTableQuery(string $table, bool $autoIncrement, string $style)
191			{
192			return $this->grammar->getCreateTableQuery($table, $autoIncrement, $style);
193			}
194
195			/**
196			* Command to create an index
197			*
198			* @param string $table
199			* @param string $type
200			* @param string $name
201			* @param string $columns
202			*
203			* @return string
204			*/
205			public function getCreateIndexQuery(string $table, string $type, string $name, string $columns)
206			{
207			return $this->grammar->getCreateIndexQuery($table, $type, $name, $columns);
208			}
209
210			/**
211			* Get SQL command to create foreign keys
212			*
213			* getCreateTableQuery() produces CREATE TABLE without FK CONSTRAINTs
214			* getForeignKeysQuery() produces all FK CONSTRAINTs as ALTER TABLE ... ADD CONSTRAINT
215			* so that all FKs can be added after all tables have been created, avoiding any need
216			* to reorder CREATE TABLE statements in order of their FK dependencies
217			*
218			* @param string $table
219			*
220			* @return string
221			*/
222			public function getForeignKeysQuery(string $table)
223			{
224			return $this->grammar->getForeignKeysQuery($table);
225			}
226
227			/**
228			* Get SQL command to truncate table
229			*
230			* @param string $table
231			*
232			* @return string
233			*/
234			public function getTruncateTableQuery(string $table)
235			{
236			return $this->grammar->getTruncateTableQuery($table);
237			}
238
239			/**
240			* Get SQL command to change database
241			*
242			* @param string $database
243			*
244			* @return string
245			*/
246			public function getUseDatabaseQuery(string $database)
247			{
248			return $this->grammar->getUseDatabaseQuery($database);
249			}
250
251			/**
252			* Get SQL commands to create triggers
253			*
254			* @param string $table
255			*
256			* @return string
257			*/
258			public function getCreateTriggerQuery(string $table)
259			{
260			return $this->grammar->getCreateTriggerQuery($table);
261			}
262
263			/**
264			* Return query to get connection ID
265			*
266			* @return string
267			*/
268			// public function connectionId()
269			// {
270			// return $this->grammar->connectionId();
271			// }
272			}
273

lagdo / dbadmin-driver

GrammarTrait::buildSelectQuery() A last analyzed 2025-08-14 05:53 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

GrammarTrait::buildSelectQuery() A
last analyzed 2025-08-14 05:53 UTC