Expression::build() - Code Metrics - Inspection of "Update generated contexts" - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 14c8dc...87c59f )

by Michal

created 2017-08-30 08:50 UTC

Expression::build() C

↳ Parent: Expression

Complexity

Conditions	11
Paths	19

Size

Total Lines	28
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	11

Importance

Changes

Metric	Value
dl	0
loc	28
ccs	16
cts	16
cp	1
rs	5.2653
c	0
b	0
f	0
cc	11
eloc	17
nc	19
nop	2
crap	11

How to fix Complexity

<?php

/**
 * Parses a reference to an expression (column, table or database name, function
 * call, mathematical expression, etc.).
 */

namespace PhpMyAdmin\SqlParser\Components;

use PhpMyAdmin\SqlParser\Component;
use PhpMyAdmin\SqlParser\Context;
use PhpMyAdmin\SqlParser\Parser;
use PhpMyAdmin\SqlParser\Token;
use PhpMyAdmin\SqlParser\TokensList;

/**
 * Parses a reference to an expression (column, table or database name, function
 * call, mathematical expression, etc.).
 *
 * @category   Components
 *
 * @license    https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
 */
class Expression extends Component
{
    /**
     * List of allowed reserved keywords in expressions.
     *
     * @var array
     */
    private static $ALLOWED_KEYWORDS = array(
        'AS' => 1, 'DUAL' => 1, 'NULL' => 1, 'REGEXP' => 1, 'CASE' => 1,
        'DIV' => 1, 'AND' => 1, 'OR' => 1, 'XOR' => 1, 'NOT' => 1, 'MOD' => 1,
    );

    /**
     * The name of this database.
     *
     * @var string
     */
    public $database;

    /**
     * The name of this table.
     *
     * @var string
     */
    public $table;

    /**
     * The name of the column.
     *
     * @var string
     */
    public $column;

    /**
     * The sub-expression.
     *
     * @var string
     */
    public $expr = '';

    /**
     * The alias of this expression.
     *
     * @var string
     */
    public $alias;

    /**
     * The name of the function.
     *
     * @var mixed
     */
    public $function;

    /**
     * The type of subquery.
     *
     * @var string
     */
    public $subquery;

    /**
     * Constructor.
     *
     * Syntax:
     *     new Expression('expr')
     *     new Expression('expr', 'alias')
     *     new Expression('database', 'table', 'column')
     *     new Expression('database', 'table', 'column', 'alias')
     *
     * If the database, table or column name is not required, pass an empty
     * string.
     *
     * @param string $database The name of the database or the the expression.

     *                         the the expression.
     * @param string $table    The name of the table or the alias of the expression.

     *                         the alias of the expression.
     * @param string $column   the name of the column

     * @param string $alias    the name of the alias

     */
    public function __construct($database = null, $table = null, $column = null, $alias = null)
    {
        if (($column === null) && ($alias === null)) {
            $this->expr = $database; // case 1
            $this->alias = $table; // case 2
        } else {
            $this->database = $database; // case 3
            $this->table = $table; // case 3
            $this->column = $column; // case 3
            $this->alias = $alias; // case 4
        }
    }

    /**
     * Possible options:.
     *
     *      `field`
     *
     *          First field to be filled.
     *          If this is not specified, it takes the value of `parseField`.
     *
     *      `parseField`
     *
     *          Specifies the type of the field parsed. It may be `database`,
     *          `table` or `column`. These expressions may not include
     *          parentheses.
     *
     *      `breakOnAlias`
     *
     *          If not empty, breaks when the alias occurs (it is not included).
     *
     *      `breakOnParentheses`
     *
     *          If not empty, breaks when the first parentheses occurs.
     *
     *      `parenthesesDelimited`
     *
     *          If not empty, breaks after last parentheses occurred.
     *
     * @param Parser     $parser  the parser that serves as context
     * @param TokensList $list    the list of tokens that are being parsed
     * @param array      $options parameters for parsing
     *
     * @return Expression

     */
    public static function parse(Parser $parser, TokensList $list, array $options = array())
    {
        $ret = new self();

        /**
         * Whether current tokens make an expression or a table reference.
         *
         * @var bool
         */
        $isExpr = false;

        /**
         * Whether a period was previously found.
         *
         * @var bool
         */
        $dot = false;

        /**
         * Whether an alias is expected. Is 2 if `AS` keyword was found.
         *
         * @var bool
         */
        $alias = false;

        /**
         * Counts brackets.
         *
         * @var int
         */
        $brackets = 0;

        /**
         * Keeps track of the last two previous tokens.
         *
         * @var Token[]
         */
        $prev = array(null, null);

        // When a field is parsed, no parentheses are expected.
        if (!empty($options['parseField'])) {
            $options['breakOnParentheses'] = true;
            $options['field'] = $options['parseField'];
        }

        for (; $list->idx < $list->count; ++$list->idx) {
            /**
             * Token parsed at this moment.
             *
             * @var Token
             */
            $token = $list->tokens[$list->idx];

            // End of statement.
            if ($token->type === Token::TYPE_DELIMITER) {
                break;
            }

            // Skipping whitespaces and comments.
            if (($token->type === Token::TYPE_WHITESPACE)
                || ($token->type === Token::TYPE_COMMENT)
            ) {
                if ($isExpr) {
                    $ret->expr .= $token->token;
                }
                continue;
            }

            if ($token->type === Token::TYPE_KEYWORD) {
                if (($brackets > 0) && (empty($ret->subquery))
                    && (!empty(Parser::$STATEMENT_PARSERS[$token->keyword]))
                ) {
                    // A `(` was previously found and this keyword is the
                    // beginning of a statement, so this is a subquery.
                    $ret->subquery = $token->keyword;
                } elseif (($token->flags & Token::FLAG_KEYWORD_FUNCTION)
                    && (empty($options['parseField'])
                    && !$alias)
                ) {
                    $isExpr = true;
                } elseif (($token->flags & Token::FLAG_KEYWORD_RESERVED)
                    && ($brackets === 0)
                ) {
                    if (empty(self::$ALLOWED_KEYWORDS[$token->keyword])) {
                        // A reserved keyword that is not allowed in the
                        // expression was found so the expression must have
                        // ended and a new clause is starting.
                        break;
                    }
                    if ($token->keyword === 'AS') {
                        if (!empty($options['breakOnAlias'])) {
                            break;
                        }
                        if ($alias) {
                            $parser->error(
                                'An alias was expected.',
                                $token
                            );
                            break;
                        }
                        $alias = true;
                        continue;
                    } elseif ($token->keyword === 'CASE') {
                        // For a use of CASE like
                        // 'SELECT a = CASE .... END, b=1, `id`, ... FROM ...'
                        $tempCaseExpr = CaseExpression::parse($parser, $list);
                        $ret->expr .= CaseExpression::build($tempCaseExpr);
                        $isExpr = true;
                        continue;
                    }
                    $isExpr = true;
                } elseif ($brackets === 0 && strlen($ret->expr) > 0 && !$alias) {
                    /* End of expression */
                    break;
                }
            }

            if (($token->type === Token::TYPE_NUMBER)
                || ($token->type === Token::TYPE_BOOL)
                || (($token->type === Token::TYPE_SYMBOL)
                && ($token->flags & Token::FLAG_SYMBOL_VARIABLE))
                || (($token->type === Token::TYPE_OPERATOR)
                && ($token->value !== '.'))
            ) {
                if (!empty($options['parseField'])) {
                    break;
                }

                // Numbers, booleans and operators (except dot) are usually part
                // of expressions.
                $isExpr = true;
            }

            if ($token->type === Token::TYPE_OPERATOR) {
                if ((!empty($options['breakOnParentheses']))
                    && (($token->value === '(') || ($token->value === ')'))
                ) {
                    // No brackets were expected.
                    break;
                }
                if ($token->value === '(') {
                    ++$brackets;
                    if ((empty($ret->function)) && ($prev[1] !== null)
                        && (($prev[1]->type === Token::TYPE_NONE)
                        || ($prev[1]->type === Token::TYPE_SYMBOL)
                        || (($prev[1]->type === Token::TYPE_KEYWORD)
                        && ($prev[1]->flags & Token::FLAG_KEYWORD_FUNCTION)))
                    ) {
                        $ret->function = $prev[1]->value;
                    }
                } elseif ($token->value === ')' && $brackets == 0) {
                    // Not our bracket
                    break;
                } elseif ($token->value === ')') {
                    --$brackets;
                    if ($brackets === 0) {
                        if (!empty($options['parenthesesDelimited'])) {
                            // The current token is the last bracket, the next
                            // one will be outside the expression.
                            $ret->expr .= $token->token;
                            ++$list->idx;
                            break;
                        }
                    } elseif ($brackets < 0) {
                        // $parser->error('Unexpected closing bracket.', $token);
                        // $brackets = 0;
                        break;
                    }
                } elseif ($token->value === ',') {
                    // Expressions are comma-delimited.
                    if ($brackets === 0) {
                        break;
                    }
                }
            }

            // Saving the previous tokens.
            $prev[0] = $prev[1];
            $prev[1] = $token;

            if ($alias) {
                // An alias is expected (the keyword `AS` was previously found).
                if (!empty($ret->alias)) {
                    $parser->error('An alias was previously found.', $token);
                    break;
                }
                $ret->alias = $token->value;
                $alias = false;
            } elseif ($isExpr) {
                // Handling aliases.
                if (/* (empty($ret->alias)) && */ ($brackets === 0)
                    && (($prev[0] === null)
                    || ((($prev[0]->type !== Token::TYPE_OPERATOR)
                    || ($prev[0]->token === ')'))
                    && (($prev[0]->type !== Token::TYPE_KEYWORD)
                    || (!($prev[0]->flags & Token::FLAG_KEYWORD_RESERVED)))))
                    && (($prev[1]->type === Token::TYPE_STRING)
                    || (($prev[1]->type === Token::TYPE_SYMBOL)
                    && (!($prev[1]->flags & Token::FLAG_SYMBOL_VARIABLE)))
                    || ($prev[1]->type === Token::TYPE_NONE))
                ) {
                    if (!empty($ret->alias)) {
                        $parser->error('An alias was previously found.', $token);
                        break;
                    }
                    $ret->alias = $prev[1]->value;
                } else {
                    $ret->expr .= $token->token;
                }
            } elseif (!$isExpr) {
                if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '.')) {
                    // Found a `.` which means we expect a column name and
                    // the column name we parsed is actually the table name
                    // and the table name is actually a database name.
                    if ((!empty($ret->database)) || ($dot)) {
                        $parser->error('Unexpected dot.', $token);
                    }
                    $ret->database = $ret->table;
                    $ret->table = $ret->column;
                    $ret->column = null;
                    $dot = true;
                    $ret->expr .= $token->token;
                } else {
                    $field = empty($options['field']) ? 'column' : $options['field'];
                    if (empty($ret->$field)) {
                        $ret->$field = $token->value;
                        $ret->expr .= $token->token;
                        $dot = false;
                    } else {
                        // No alias is expected.
                        if (!empty($options['breakOnAlias'])) {
                            break;
                        }
                        if (!empty($ret->alias)) {
                            $parser->error('An alias was previously found.', $token);
                            break;
                        }
                        $ret->alias = $token->value;
                    }
                }
            }
        }

        if ($alias) {
            $parser->error(
                'An alias was expected.',
                $list->tokens[$list->idx - 1]
            );
        }

        // White-spaces might be added at the end.
        $ret->expr = trim($ret->expr);

        if ($ret->expr === '') {
            return null;
        }

        --$list->idx;

        return $ret;
    }

    /**
     * @param Expression|Expression[] $component the component to be built
     * @param array                   $options   parameters for building
     *
     * @return string
     */
    public static function build($component, array $options = array())
    {
        if (is_array($component)) {
            return implode($component, ', ');
        }

        if ($component->expr !== '' && !is_null($component->expr)) {
            $ret = $component->expr;
        } else {
            $fields = array();
            if ((isset($component->database)) && ($component->database !== '')) {
                $fields[] = $component->database;
            }
            if ((isset($component->table)) && ($component->table !== '')) {
                $fields[] = $component->table;
            }
            if ((isset($component->column)) && ($component->column !== '')) {
                $fields[] = $component->column;
            }
            $ret = implode('.', Context::escape($fields));
        }

        if (!empty($component->alias)) {
            $ret .= ' AS ' . Context::escape($component->alias);
        }

        return $ret;
    }
}


1		<?php
2
3		/**
4		* Parses a reference to an expression (column, table or database name, function
5		* call, mathematical expression, etc.).
6		*/
7
8		namespace PhpMyAdmin\SqlParser\Components;
9
10		use PhpMyAdmin\SqlParser\Component;
11		use PhpMyAdmin\SqlParser\Context;
12		use PhpMyAdmin\SqlParser\Parser;
13		use PhpMyAdmin\SqlParser\Token;
14		use PhpMyAdmin\SqlParser\TokensList;
15
16		/**
17		* Parses a reference to an expression (column, table or database name, function
18		* call, mathematical expression, etc.).
19		*
20		* @category Components
21		*
22		* @license https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
23		*/
24		class Expression extends Component
25		{
26		/**
27		* List of allowed reserved keywords in expressions.
28		*
29		* @var array
30		*/
31		private static $ALLOWED_KEYWORDS = array(
32		'AS' => 1, 'DUAL' => 1, 'NULL' => 1, 'REGEXP' => 1, 'CASE' => 1,
33		'DIV' => 1, 'AND' => 1, 'OR' => 1, 'XOR' => 1, 'NOT' => 1, 'MOD' => 1,
34		);
35
36		/**
37		* The name of this database.
38		*
39		* @var string
40		*/
41		public $database;
42
43		/**
44		* The name of this table.
45		*
46		* @var string
47		*/
48		public $table;
49
50		/**
51		* The name of the column.
52		*
53		* @var string
54		*/
55		public $column;
56
57		/**
58		* The sub-expression.
59		*
60		* @var string
61		*/
62		public $expr = '';
63
64		/**
65		* The alias of this expression.
66		*
67		* @var string
68		*/
69		public $alias;
70
71		/**
72		* The name of the function.
73		*
74		* @var mixed
75		*/
76		public $function;
77
78		/**
79		* The type of subquery.
80		*
81		* @var string
82		*/
83		public $subquery;
84
85		/**
86		* Constructor.
87		*
88		* Syntax:
89		* new Expression('expr')
90		* new Expression('expr', 'alias')
91		* new Expression('database', 'table', 'column')
92		* new Expression('database', 'table', 'column', 'alias')
93		*
94		* If the database, table or column name is not required, pass an empty
95		* string.
96		*
97		* @param string $database The name of the database or the the expression.
		0 ignored issues – show Documentation introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Should the type for parameter `$database` not be `string\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
98		* the the expression.
99		* @param string $table The name of the table or the alias of the expression.
		0 ignored issues – show Documentation introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Should the type for parameter `$table` not be `string\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
100		* the alias of the expression.
101		* @param string $column the name of the column
		0 ignored issues – show Documentation introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Should the type for parameter `$column` not be `string\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
102		* @param string $alias the name of the alias
		0 ignored issues – show Documentation introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Should the type for parameter `$alias` not be `string\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
103		*/
104	270	public function __construct($database = null, $table = null, $column = null, $alias = null)
105		{
106	270	if (($column === null) && ($alias === null)) {
107	270	$this->expr = $database; // case 1
108	270	$this->alias = $table; // case 2
109		} else {
110	2	$this->database = $database; // case 3
111	2	$this->table = $table; // case 3
112	2	$this->column = $column; // case 3
113	2	$this->alias = $alias; // case 4
114		}
115	270	}
116
117		/**
118		* Possible options:.
119		*
120		* `field`
121		*
122		* First field to be filled.
123		* If this is not specified, it takes the value of `parseField`.
124		*
125		* `parseField`
126		*
127		* Specifies the type of the field parsed. It may be `database`,
128		* `table` or `column`. These expressions may not include
129		* parentheses.
130		*
131		* `breakOnAlias`
132		*
133		* If not empty, breaks when the alias occurs (it is not included).
134		*
135		* `breakOnParentheses`
136		*
137		* If not empty, breaks when the first parentheses occurs.
138		*
139		* `parenthesesDelimited`
140		*
141		* If not empty, breaks after last parentheses occurred.
142		*
143		* @param Parser $parser the parser that serves as context
144		* @param TokensList $list the list of tokens that are being parsed
145		* @param array $options parameters for parsing
146		*
147		* @return Expression
		0 ignored issues – show Documentation introduced 2016-02-12 21:51 UTC by Report Bug Copy Issue Report Should the return type not be `Expression\|null`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
148		*/
149	264	public static function parse(Parser $parser, TokensList $list, array $options = array())
150		{
151	264	$ret = new self();
152
153		/**
154		* Whether current tokens make an expression or a table reference.
155		*
156		* @var bool
157		*/
158	264	$isExpr = false;
159
160		/**
161		* Whether a period was previously found.
162		*
163		* @var bool
164		*/
165	264	$dot = false;
166
167		/**
168		* Whether an alias is expected. Is 2 if `AS` keyword was found.
169		*
170		* @var bool
171		*/
172	264	$alias = false;
173
174		/**
175		* Counts brackets.
176		*
177		* @var int
178		*/
179	264	$brackets = 0;
180
181		/**
182		* Keeps track of the last two previous tokens.
183		*
184		* @var Token[]
185		*/
186	264	$prev = array(null, null);
187
188		// When a field is parsed, no parentheses are expected.
189	264	if (!empty($options['parseField'])) {
190	127	$options['breakOnParentheses'] = true;
191	127	$options['field'] = $options['parseField'];
192		}
193
194	264	for (; $list->idx < $list->count; ++$list->idx) {
195		/**
196		* Token parsed at this moment.
197		*
198		* @var Token
199		*/
200	264	$token = $list->tokens[$list->idx];
201
202		// End of statement.
203	264	if ($token->type === Token::TYPE_DELIMITER) {
204	105	break;
205		}
206
207		// Skipping whitespaces and comments.
208	263	if (($token->type === Token::TYPE_WHITESPACE)
209	263	\|\| ($token->type === Token::TYPE_COMMENT)
210		) {
211	214	if ($isExpr) {
212	104	$ret->expr .= $token->token;
213		}
214	214	continue;
215		}
216
217	263	if ($token->type === Token::TYPE_KEYWORD) {
218	197	if (($brackets > 0) && (empty($ret->subquery))
219	25	&& (!empty(Parser::$STATEMENT_PARSERS[$token->keyword]))
220		) {
221		// A `(` was previously found and this keyword is the
222		// beginning of a statement, so this is a subquery.
223	20	$ret->subquery = $token->keyword;
224	196	} elseif (($token->flags & Token::FLAG_KEYWORD_FUNCTION)
225	28	&& (empty($options['parseField'])
226	19	&& !$alias)
227		) {
228	17	$isExpr = true;
229	191	} elseif (($token->flags & Token::FLAG_KEYWORD_RESERVED)
230	184	&& ($brackets === 0)
231		) {
232	184	if (empty(self::$ALLOWED_KEYWORDS[$token->keyword])) {
233		// A reserved keyword that is not allowed in the
234		// expression was found so the expression must have
235		// ended and a new clause is starting.
236	173	break;
237		}
238	46	if ($token->keyword === 'AS') {
239	37	if (!empty($options['breakOnAlias'])) {
240	5	break;
241		}
242	32	if ($alias) {
243	1	$parser->error(
244	1	'An alias was expected.',
245	1	$token
246		);
247	1	break;
248		}
249	32	$alias = true;
250	32	continue;
251	10	} elseif ($token->keyword === 'CASE') {
252		// For a use of CASE like
253		// 'SELECT a = CASE .... END, b=1, `id`, ... FROM ...'
254	1	$tempCaseExpr = CaseExpression::parse($parser, $list);
255	1	$ret->expr .= CaseExpression::build($tempCaseExpr);
256	1	$isExpr = true;
257	1	continue;
258		}
259	9	$isExpr = true;
260	47	} elseif ($brackets === 0 && strlen($ret->expr) > 0 && !$alias) {
261		/* End of expression */
262	28	break;
263		}
264		}
265
266	261	if (($token->type === Token::TYPE_NUMBER)
267	254	\|\| ($token->type === Token::TYPE_BOOL)
268	254	\|\| (($token->type === Token::TYPE_SYMBOL)
269	63	&& ($token->flags & Token::FLAG_SYMBOL_VARIABLE))
270	254	\|\| (($token->type === Token::TYPE_OPERATOR)
271	173	&& ($token->value !== '.'))
272		) {
273	187	if (!empty($options['parseField'])) {
274	61	break;
275		}
276
277		// Numbers, booleans and operators (except dot) are usually part
278		// of expressions.
279	147	$isExpr = true;
280		}
281
282	261	if ($token->type === Token::TYPE_OPERATOR) {
283	136	if ((!empty($options['breakOnParentheses']))
284	4	&& (($token->value === '(') \|\| ($token->value === ')'))
285		) {
286		// No brackets were expected.
287	2	break;
288		}
289	135	if ($token->value === '(') {
290	45	++$brackets;
291	45	if ((empty($ret->function)) && ($prev[1] !== null)
292	11	&& (($prev[1]->type === Token::TYPE_NONE)
293	10	\|\| ($prev[1]->type === Token::TYPE_SYMBOL)
294	10	\|\| (($prev[1]->type === Token::TYPE_KEYWORD)
295	10	&& ($prev[1]->flags & Token::FLAG_KEYWORD_FUNCTION)))
296		) {
297	11	$ret->function = $prev[1]->value;
298		}
299	135	} elseif ($token->value === ')' && $brackets == 0) {
300		// Not our bracket
301	6	break;
302	131	} elseif ($token->value === ')') {
303	45	--$brackets;
304	45	if ($brackets === 0) {
305	45	if (!empty($options['parenthesesDelimited'])) {
306		// The current token is the last bracket, the next
307		// one will be outside the expression.
308	7	$ret->expr .= $token->token;
309	7	++$list->idx;
310	7	break;
311		}
312	2	} elseif ($brackets < 0) {
313		// $parser->error('Unexpected closing bracket.', $token);
314		// $brackets = 0;
315		break;
316		}
317	124	} elseif ($token->value === ',') {
318		// Expressions are comma-delimited.
319	79	if ($brackets === 0) {
320	70	break;
321		}
322		}
323		}
324
325		// Saving the previous tokens.
326	260	$prev[0] = $prev[1];
327	260	$prev[1] = $token;
328
329	260	if ($alias) {
330		// An alias is expected (the keyword `AS` was previously found).
331	31	if (!empty($ret->alias)) {
332	1	$parser->error('An alias was previously found.', $token);
333	1	break;
334		}
335	31	$ret->alias = $token->value;
336	31	$alias = false;
337	260	} elseif ($isExpr) {
338		// Handling aliases.
339	126	if (/* (empty($ret->alias)) && */ ($brackets === 0)
340	120	&& (($prev[0] === null)
341	58	\|\| ((($prev[0]->type !== Token::TYPE_OPERATOR)
342	25	\|\| ($prev[0]->token === ')'))
343	49	&& (($prev[0]->type !== Token::TYPE_KEYWORD)
344	2	\|\| (!($prev[0]->flags & Token::FLAG_KEYWORD_RESERVED)))))
345	112	&& (($prev[1]->type === Token::TYPE_STRING)
346	112	\|\| (($prev[1]->type === Token::TYPE_SYMBOL)
347	7	&& (!($prev[1]->flags & Token::FLAG_SYMBOL_VARIABLE)))
348	112	\|\| ($prev[1]->type === Token::TYPE_NONE))
349		) {
350	6	if (!empty($ret->alias)) {
351	2	$parser->error('An alias was previously found.', $token);
352	2	break;
353		}
354	5	$ret->alias = $prev[1]->value;
355		} else {
356	126	$ret->expr .= $token->token;
357		}
358		} elseif (!$isExpr) {
359	240	if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '.')) {
360		// Found a `.` which means we expect a column name and
361		// the column name we parsed is actually the table name
362		// and the table name is actually a database name.
363	29	if ((!empty($ret->database)) \|\| ($dot)) {
364	2	$parser->error('Unexpected dot.', $token);
365		}
366	29	$ret->database = $ret->table;
367	29	$ret->table = $ret->column;
368	29	$ret->column = null;
369	29	$dot = true;
370	29	$ret->expr .= $token->token;
371		} else {
372	240	$field = empty($options['field']) ? 'column' : $options['field'];
373	240	if (empty($ret->$field)) {
374	240	$ret->$field = $token->value;
375	240	$ret->expr .= $token->token;
376	240	$dot = false;
377		} else {
378		// No alias is expected.
379	12	if (!empty($options['breakOnAlias'])) {
380	3	break;
381		}
382	9	if (!empty($ret->alias)) {
383	2	$parser->error('An alias was previously found.', $token);
384	2	break;
385		}
386	8	$ret->alias = $token->value;
387		}
388		}
389		}
390		}
391
392	264	if ($alias) {
393	3	$parser->error(
394	3	'An alias was expected.',
395	3	$list->tokens[$list->idx - 1]
396		);
397		}
398
399		// White-spaces might be added at the end.
400	264	$ret->expr = trim($ret->expr);
401
402	264	if ($ret->expr === '') {
403	10	return null;
404		}
405
406	260	--$list->idx;
407
408	260	return $ret;
409		}
410
411		/**
412		* @param Expression\|Expression[] $component the component to be built
413		* @param array $options parameters for building
414		*
415		* @return string
416		*/
417	54	public static function build($component, array $options = array())
418		{
419	54	if (is_array($component)) {
420	1	return implode($component, ', ');
421		}
422
423	54	if ($component->expr !== '' && !is_null($component->expr)) {
424	48	$ret = $component->expr;
425		} else {
426	8	$fields = array();
427	8	if ((isset($component->database)) && ($component->database !== '')) {
428	1	$fields[] = $component->database;
429		}
430	8	if ((isset($component->table)) && ($component->table !== '')) {
431	8	$fields[] = $component->table;
432		}
433	8	if ((isset($component->column)) && ($component->column !== '')) {
434	1	$fields[] = $component->column;
435		}
436	8	$ret = implode('.', Context::escape($fields));
437		}
438
439	54	if (!empty($component->alias)) {
440	4	$ret .= ' AS ' . Context::escape($component->alias);
441		}
442
443	54	return $ret;
444		}
445		}
446

phpmyadmin / sql-parser

Push — master ( 14c8dc...87c59f )

Expression::build() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like