Context - Code Metrics - Inspection of "EXISTS also is a function-ish, not only keyword" - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#297)

unknown

created 2020-04-08 05:43 UTC

Context F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	595
Duplicated Lines	1.34 %

Coupling/Cohesion

Components	2
Dependencies	0

Test Coverage

Coverage

94.64%

Importance

Changes

Metric	Value
wmc	81
lcom	2
cbo	0
dl	8
loc	595
ccs	106
cts	112
cp	0.9464
rs	2
c	0
b	0
f	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	isKeyword()	0	14	4
A	isOperator()	0	8	2
A	isWhitespace()	0	4	4
D	isComment()	8	33	19
A	isBool()	0	6	2
B	isNumber()	0	5	7
A	isSymbol()	0	15	6
A	isString()	0	13	4
B	isSeparator()	0	9	8
B	loadClosest()	0	29	8
A	setMode()	0	11	3
B	escape()	0	22	6
A	load()	0	18	4
A	getIdentifierQuote()	0	4	2
A	hasMode()	0	7	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Context often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Context, and based on these observations, apply Extract Interface, too.

<?php

/**
 * Defines a context class that is later extended to define other contexts.
 *
 * A context is a collection of keywords, operators and functions used for
 * parsing.
 */

namespace PhpMyAdmin\SqlParser;

use PhpMyAdmin\SqlParser\Exceptions\LoaderException;

/**
 * Holds the configuration of the context that is currently used.
 *
 * @category Contexts
 *
 * @license  https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
 */
abstract class Context
{
    /**
     * The maximum length of a keyword.
     *
     * @see static::$TOKEN_KEYWORD
     *
     * @var int
     */
    const KEYWORD_MAX_LENGTH = 30;

    /**
     * The maximum length of a label.
     *
     * @see static::$TOKEN_LABEL
     * Ref: https://dev.mysql.com/doc/refman/5.7/en/statement-labels.html
     *
     * @var int
     */
    const LABEL_MAX_LENGTH = 16;

    /**
     * The maximum length of an operator.
     *
     * @see static::$TOKEN_OPERATOR
     *
     * @var int
     */
    const OPERATOR_MAX_LENGTH = 4;

    /**
     * The name of the default content.
     *
     * @var string
     */
    public static $defaultContext = '\\PhpMyAdmin\\SqlParser\\Contexts\\ContextMySql50700';

    /**
     * The name of the loaded context.
     *
     * @var string
     */
    public static $loadedContext = '\\PhpMyAdmin\\SqlParser\\Contexts\\ContextMySql50700';

    /**
     * The prefix concatenated to the context name when an incomplete class name
     * is specified.
     *
     * @var string
     */
    public static $contextPrefix = '\\PhpMyAdmin\\SqlParser\\Contexts\\Context';

    /**
     * List of keywords.
     *
     * Because, PHP's associative arrays are basically hash tables, it is more
     * efficient to store keywords as keys instead of values.
     *
     * The value associated to each keyword represents its flags.
     *
     * @see Token::FLAG_KEYWORD_RESERVED Token::FLAG_KEYWORD_COMPOSED
     *      Token::FLAG_KEYWORD_DATA_TYPE Token::FLAG_KEYWORD_KEY
     *      Token::FLAG_KEYWORD_FUNCTION
     *
     * Elements are sorted by flags, length and keyword.
     *
     * @var array
     */
    public static $KEYWORDS = array();

    /**
     * List of operators and their flags.
     *
     * @var array
     */
    public static $OPERATORS = array(
        // Some operators (*, =) may have ambiguous flags, because they depend on
        // the context they are being used in.
        // For example: 1. SELECT * FROM table; # SQL specific (wildcard)
        //                 SELECT 2 * 3;        # arithmetic
        //              2. SELECT * FROM table WHERE foo = 'bar';
        //                 SET @i = 0;

        // @see Token::FLAG_OPERATOR_ARITHMETIC
        '%' => 1,
        '*' => 1,
        '+' => 1,
        '-' => 1,
        '/' => 1,

        // @see Token::FLAG_OPERATOR_LOGICAL
        '!' => 2,
        '!=' => 2,
        '&&' => 2,
        '<' => 2,
        '<=' => 2,
        '<=>' => 2,
        '<>' => 2,
        '=' => 2,
        '>' => 2,
        '>=' => 2,
        '||' => 2,

        // @see Token::FLAG_OPERATOR_BITWISE
        '&' => 4,
        '<<' => 4,
        '>>' => 4,
        '^' => 4,
        '|' => 4,
        '~' => 4,

        // @see Token::FLAG_OPERATOR_ASSIGNMENT
        ':=' => 8,

        // @see Token::FLAG_OPERATOR_SQL
        '(' => 16,
        ')' => 16,
        '.' => 16,
        ',' => 16,
        ';' => 16
    );

    /**
     * The mode of the MySQL server that will be used in lexing, parsing and
     * building the statements.
     *
     * @var int
     */
    public static $MODE = 0;

    /*
     * Server SQL Modes
     * https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html
     */

    // Compatibility mode for Microsoft's SQL server.
    // This is the equivalent of ANSI_QUOTES.
    const SQL_MODE_COMPAT_MYSQL = 2;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_allow_invalid_dates
    const SQL_MODE_ALLOW_INVALID_DATES = 1;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_ansi_quotes
    const SQL_MODE_ANSI_QUOTES = 2;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_error_for_division_by_zero
    const SQL_MODE_ERROR_FOR_DIVISION_BY_ZERO = 4;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_high_not_precedence
    const SQL_MODE_HIGH_NOT_PRECEDENCE = 8;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_ignore_space
    const SQL_MODE_IGNORE_SPACE = 16;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_auto_create_user
    const SQL_MODE_NO_AUTO_CREATE_USER = 32;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_auto_value_on_zero
    const SQL_MODE_NO_AUTO_VALUE_ON_ZERO = 64;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_backslash_escapes
    const SQL_MODE_NO_BACKSLASH_ESCAPES = 128;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_dir_in_create
    const SQL_MODE_NO_DIR_IN_CREATE = 256;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_dir_in_create
    const SQL_MODE_NO_ENGINE_SUBSTITUTION = 512;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_field_options
    const SQL_MODE_NO_FIELD_OPTIONS = 1024;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_key_options
    const SQL_MODE_NO_KEY_OPTIONS = 2048;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_table_options
    const SQL_MODE_NO_TABLE_OPTIONS = 4096;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_unsigned_subtraction
    const SQL_MODE_NO_UNSIGNED_SUBTRACTION = 8192;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_zero_date
    const SQL_MODE_NO_ZERO_DATE = 16384;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_zero_in_date
    const SQL_MODE_NO_ZERO_IN_DATE = 32768;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_only_full_group_by
    const SQL_MODE_ONLY_FULL_GROUP_BY = 65536;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_pipes_as_concat
    const SQL_MODE_PIPES_AS_CONCAT = 131072;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_real_as_float
    const SQL_MODE_REAL_AS_FLOAT = 262144;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_strict_all_tables
    const SQL_MODE_STRICT_ALL_TABLES = 524288;

    // https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_strict_trans_tables
    const SQL_MODE_STRICT_TRANS_TABLES = 1048576;

    // Custom modes.

    // The table and column names and any other field that must be escaped will
    // not be.
    // Reserved keywords are being escaped regardless this mode is used or not.
    const SQL_MODE_NO_ENCLOSING_QUOTES = 1073741824;

    /*
     * Combination SQL Modes
     * https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sql-mode-combo
     */

    // REAL_AS_FLOAT, PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE
    const SQL_MODE_ANSI = 393234;

    // PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
    // NO_TABLE_OPTIONS, NO_FIELD_OPTIONS,
    const SQL_MODE_DB2 = 138258;

    // PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
    // NO_TABLE_OPTIONS, NO_FIELD_OPTIONS, NO_AUTO_CREATE_USER
    const SQL_MODE_MAXDB = 138290;

    // PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
    // NO_TABLE_OPTIONS, NO_FIELD_OPTIONS
    const SQL_MODE_MSSQL = 138258;

    // PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
    // NO_TABLE_OPTIONS, NO_FIELD_OPTIONS, NO_AUTO_CREATE_USER
    const SQL_MODE_ORACLE = 138290;

    // PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
    // NO_TABLE_OPTIONS, NO_FIELD_OPTIONS
    const SQL_MODE_POSTGRESQL = 138258;

    // STRICT_TRANS_TABLES, STRICT_ALL_TABLES, NO_ZERO_IN_DATE, NO_ZERO_DATE,
    // ERROR_FOR_DIVISION_BY_ZERO, NO_AUTO_CREATE_USER
    const SQL_MODE_TRADITIONAL = 1622052;

    // -------------------------------------------------------------------------
    // Keyword.

    /**
     * Checks if the given string is a keyword.
     *
     * @param string $str        string to be checked
     * @param bool   $isReserved checks if the keyword is reserved
     *
     * @return int|null
     */
    public static function isKeyword($str, $isReserved = false)
    {
        $str = strtoupper($str);

        if (isset(static::$KEYWORDS[$str])) {
            if ($isReserved && ! (static::$KEYWORDS[$str] & Token::FLAG_KEYWORD_RESERVED)) {
                return null;
            }

            return static::$KEYWORDS[$str];
        }

        return null;
    }

    // -------------------------------------------------------------------------
    // Operator.

    /**
     * Checks if the given string is an operator.
     *
     * @param string $str string to be checked
     *
     * @return int|null the appropriate flag for the operator
     */
    public static function isOperator($str)
    {
        if (! isset(static::$OPERATORS[$str])) {
            return null;
        }

        return static::$OPERATORS[$str];
    }

    // -------------------------------------------------------------------------
    // Whitespace.

    /**
     * Checks if the given character is a whitespace.
     *
     * @param string $str string to be checked
     *
     * @return bool
     */
    public static function isWhitespace($str)
    {
        return ($str === ' ') || ($str === "\r") || ($str === "\n") || ($str === "\t");
    }

    // -------------------------------------------------------------------------
    // Comment.

    /**
     * Checks if the given string is the beginning of a whitespace.
     *
     * @param string $str string to be checked
     * @param mixed  $end
     *
     * @return int|null the appropriate flag for the comment type
     */
    public static function isComment($str, $end = false)
    {
        $len = strlen($str);
        if ($len === 0) {
            return null;
        }

        // If comment is Bash style (#):
        if ($str[0] === '#') {
            return Token::FLAG_COMMENT_BASH;
        }
        // If comment is opening C style (/*), warning, it could be a MySQL command (/*!)
        if (($len > 1) && ($str[0] === '/') && ($str[1] === '*')) {
            return ($len > 2) && ($str[2] === '!') ?
                Token::FLAG_COMMENT_MYSQL_CMD : Token::FLAG_COMMENT_C;
        }
        // If comment is closing C style (*/), warning, it could conflicts with wildcard and a real opening C style.
        // It would looks like the following valid SQL statement: "SELECT */* comment */ FROM...".
        if (($len > 1) && ($str[0] === '*') && ($str[1] === '/')) {
            return Token::FLAG_COMMENT_C;
        }
        // If comment is SQL style (--\s?):
        if (($len > 2) && ($str[0] === '-')
            && ($str[1] === '-') && static::isWhitespace($str[2])
        ) {
            return Token::FLAG_COMMENT_SQL;
        }
        if (($len === 2) && $end && ($str[0] === '-') && ($str[1] === '-')) {
            return Token::FLAG_COMMENT_SQL;
        }

        return null;
    }

    // -------------------------------------------------------------------------
    // Bool.

    /**
     * Checks if the given string is a boolean value.
     * This actually check only for `TRUE` and `FALSE` because `1` or `0` are
     * actually numbers and are parsed by specific methods.
     *
     * @param string $str string to be checked
     *
     * @return bool
     */
    public static function isBool($str)
    {
        $str = strtoupper($str);

        return ($str === 'TRUE') || ($str === 'FALSE');
    }

    // -------------------------------------------------------------------------
    // Number.

    /**
     * Checks if the given character can be a part of a number.
     *
     * @param string $str string to be checked
     *
     * @return bool
     */
    public static function isNumber($str)
    {
        return (($str >= '0') && ($str <= '9')) || ($str === '.')
            || ($str === '-') || ($str === '+') || ($str === 'e') || ($str === 'E');
    }

    // -------------------------------------------------------------------------
    // Symbol.

    /**
     * Checks if the given character is the beginning of a symbol. A symbol
     * can be either a variable or a field name.
     *
     * @param string $str string to be checked
     *
     * @return int|null the appropriate flag for the symbol type
     */
    public static function isSymbol($str)
    {
        if (strlen($str) === 0) {
            return null;
        }
        if ($str[0] === '@') {
            return Token::FLAG_SYMBOL_VARIABLE;
        } elseif ($str[0] === '`') {
            return Token::FLAG_SYMBOL_BACKTICK;
        } elseif ($str[0] === ':' || $str[0] === '?') {
            return Token::FLAG_SYMBOL_PARAMETER;
        }

        return null;
    }

    // -------------------------------------------------------------------------
    // String.

    /**
     * Checks if the given character is the beginning of a string.
     *
     * @param string $str string to be checked
     *
     * @return int|null the appropriate flag for the string type
     */
    public static function isString($str)
    {
        if (strlen($str) === 0) {
            return null;
        }
        if ($str[0] === '\'') {
            return Token::FLAG_STRING_SINGLE_QUOTES;
        } elseif ($str[0] === '"') {
            return Token::FLAG_STRING_DOUBLE_QUOTES;
        }

        return null;
    }

    // -------------------------------------------------------------------------
    // Delimiter.

    /**
     * Checks if the given character can be a separator for two lexeme.
     *
     * @param string $str string to be checked
     *
     * @return bool
     */
    public static function isSeparator($str)
    {
        // NOTES:   Only non alphanumeric ASCII characters may be separators.
        //          `~` is the last printable ASCII character.
        return ($str <= '~') && ($str !== '_')
            && (($str < '0') || ($str > '9'))
            && (($str < 'a') || ($str > 'z'))
            && (($str < 'A') || ($str > 'Z'));
    }

    /**
     * Loads the specified context.
     *
     * Contexts may be used by accessing the context directly.
     *
     * @param string $context name of the context or full class name that
     *                        defines the context
     *
     * @throws LoaderException if the specified context doesn't exist
     */
    public static function load($context = '')
    {
        if (empty($context)) {
            $context = self::$defaultContext;
        }
        if ($context[0] !== '\\') {
            // Short context name (must be formatted into class name).
            $context = self::$contextPrefix . $context;
        }
        if (! class_exists($context)) {
            throw @new LoaderException(
                'Specified context ("' . $context . '") does not exist.',
                $context
            );
        }
        self::$loadedContext = $context;
        self::$KEYWORDS = $context::$KEYWORDS;
    }

    /**
     * Loads the context with the closest version to the one specified.
     *
     * The closest context is found by replacing last digits with zero until one
     * is loaded successfully.
     *
     * @see Context::load()
     *
     * @param string $context name of the context or full class name that
     *                        defines the context
     *
     * @return string|null The loaded context. `null` if no context was loaded.
     */
    public static function loadClosest($context = '')
    {
        $length = strlen($context);
        for ($i = $length; $i > 0;) {
            try {
                /* Trying to load the new context */
                static::load($context);
                return $context;
            } catch (LoaderException $e) {
                /* Replace last two non zero digits by zeroes */
                do {
                    $i -= 2;
                    $part = substr($context, $i, 2);
                    /* No more numeric parts to strip */
                    if (! is_numeric($part)) {
                        break 2;
                    }
                } while (intval($part) === 0 && $i > 0);
                $context = substr($context, 0, $i) . '00' . substr($context, $i + 2);
            }
        }
        /* Fallback to loading at least matching engine */
        if (strncmp($context, 'MariaDb', 7) === 0) {
            return static::loadClosest('MariaDb100300');
        } elseif (strncmp($context, 'MySql', 5) === 0) {
            return static::loadClosest('MySql50700');
        }
        return null;
    }

    /**
     * Sets the SQL mode.
     *
     * @param string $mode The list of modes. If empty, the mode is reset.
     */
    public static function setMode($mode = '')
    {
        static::$MODE = 0;
        if (empty($mode)) {
            return;
        }
        $mode = explode(',', $mode);
        foreach ($mode as $m) {
            static::$MODE |= constant('static::SQL_MODE_' . $m);
        }
    }

    /**
     * Escapes the symbol by adding surrounding backticks.
     *
     * @param array|string $str   the string to be escaped
     * @param string       $quote quote to be used when escaping
     *
     * @return string|array
     */
    public static function escape($str, $quote = '`')
    {
        if (is_array($str)) {
            foreach ($str as $key => $value) {
                $str[$key] = static::escape($value);
            }

            return $str;
        }

        if ((static::$MODE & self::SQL_MODE_NO_ENCLOSING_QUOTES)
            && (! static::isKeyword($str, true))
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
        ) {
            return $str;
        }

        if (static::$MODE & self::SQL_MODE_ANSI_QUOTES) {
            $quote = '"';
        }

        return $quote . str_replace($quote, $quote . $quote, $str) . $quote;
    }

    /**
     * Returns char used to quote identifiers based on currently set SQL Mode (ie. standard or ANSI_QUOTES)
     * @return string either " (double quote, ansi_quotes mode) or ` (backtick, standard mode)
     */
    public static function getIdentifierQuote()
    {
        return self::hasMode(self::SQL_MODE_ANSI_QUOTES) ? '"' : '`';
    }

    /**
     * Function verifies that given SQL Mode constant is currently set
     *
     * @return boolean false on empty param, true/false on given constant/int value
     * @param int $flag for example Context::SQL_MODE_ANSI_QUOTES

     */
    public static function hasMode($flag = null)
    {
        if (empty($flag)) {
            return false;
        }
        return (self::$MODE & $flag) === $flag;
    }
}

// Initializing the default context.
Context::load();


1			<?php
2
3			/**
4			* Defines a context class that is later extended to define other contexts.
5			*
6			* A context is a collection of keywords, operators and functions used for
7			* parsing.
8			*/
9
10			namespace PhpMyAdmin\SqlParser;
11
12			use PhpMyAdmin\SqlParser\Exceptions\LoaderException;
13
14			/**
15			* Holds the configuration of the context that is currently used.
16			*
17			* @category Contexts
18			*
19			* @license https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
20			*/
21			abstract class Context
22			{
23			/**
24			* The maximum length of a keyword.
25			*
26			* @see static::$TOKEN_KEYWORD
27			*
28			* @var int
29			*/
30			const KEYWORD_MAX_LENGTH = 30;
31
32			/**
33			* The maximum length of a label.
34			*
35			* @see static::$TOKEN_LABEL
36			* Ref: https://dev.mysql.com/doc/refman/5.7/en/statement-labels.html
37			*
38			* @var int
39			*/
40			const LABEL_MAX_LENGTH = 16;
41
42			/**
43			* The maximum length of an operator.
44			*
45			* @see static::$TOKEN_OPERATOR
46			*
47			* @var int
48			*/
49			const OPERATOR_MAX_LENGTH = 4;
50
51			/**
52			* The name of the default content.
53			*
54			* @var string
55			*/
56			public static $defaultContext = '\\PhpMyAdmin\\SqlParser\\Contexts\\ContextMySql50700';
57
58			/**
59			* The name of the loaded context.
60			*
61			* @var string
62			*/
63			public static $loadedContext = '\\PhpMyAdmin\\SqlParser\\Contexts\\ContextMySql50700';
64
65			/**
66			* The prefix concatenated to the context name when an incomplete class name
67			* is specified.
68			*
69			* @var string
70			*/
71			public static $contextPrefix = '\\PhpMyAdmin\\SqlParser\\Contexts\\Context';
72
73			/**
74			* List of keywords.
75			*
76			* Because, PHP's associative arrays are basically hash tables, it is more
77			* efficient to store keywords as keys instead of values.
78			*
79			* The value associated to each keyword represents its flags.
80			*
81			* @see Token::FLAG_KEYWORD_RESERVED Token::FLAG_KEYWORD_COMPOSED
82			* Token::FLAG_KEYWORD_DATA_TYPE Token::FLAG_KEYWORD_KEY
83			* Token::FLAG_KEYWORD_FUNCTION
84			*
85			* Elements are sorted by flags, length and keyword.
86			*
87			* @var array
88			*/
89			public static $KEYWORDS = array();
90
91			/**
92			* List of operators and their flags.
93			*
94			* @var array
95			*/
96			public static $OPERATORS = array(
97			// Some operators (*, =) may have ambiguous flags, because they depend on
98			// the context they are being used in.
99			// For example: 1. SELECT * FROM table; # SQL specific (wildcard)
100			// SELECT 2 * 3; # arithmetic
101			// 2. SELECT * FROM table WHERE foo = 'bar';
102			// SET @i = 0;
103
104			// @see Token::FLAG_OPERATOR_ARITHMETIC
105			'%' => 1,
106			'*' => 1,
107			'+' => 1,
108			'-' => 1,
109			'/' => 1,
110
111			// @see Token::FLAG_OPERATOR_LOGICAL
112			'!' => 2,
113			'!=' => 2,
114			'&&' => 2,
115			'<' => 2,
116			'<=' => 2,
117			'<=>' => 2,
118			'<>' => 2,
119			'=' => 2,
120			'>' => 2,
121			'>=' => 2,
122			'\|\|' => 2,
123
124			// @see Token::FLAG_OPERATOR_BITWISE
125			'&' => 4,
126			'<<' => 4,
127			'>>' => 4,
128			'^' => 4,
129			'\|' => 4,
130			'~' => 4,
131
132			// @see Token::FLAG_OPERATOR_ASSIGNMENT
133			':=' => 8,
134
135			// @see Token::FLAG_OPERATOR_SQL
136			'(' => 16,
137			')' => 16,
138			'.' => 16,
139			',' => 16,
140			';' => 16
141			);
142
143			/**
144			* The mode of the MySQL server that will be used in lexing, parsing and
145			* building the statements.
146			*
147			* @var int
148			*/
149			public static $MODE = 0;
150
151			/*
152			* Server SQL Modes
153			* https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html
154			*/
155
156			// Compatibility mode for Microsoft's SQL server.
157			// This is the equivalent of ANSI_QUOTES.
158			const SQL_MODE_COMPAT_MYSQL = 2;
159
160			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_allow_invalid_dates
161			const SQL_MODE_ALLOW_INVALID_DATES = 1;
162
163			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_ansi_quotes
164			const SQL_MODE_ANSI_QUOTES = 2;
165
166			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_error_for_division_by_zero
167			const SQL_MODE_ERROR_FOR_DIVISION_BY_ZERO = 4;
168
169			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_high_not_precedence
170			const SQL_MODE_HIGH_NOT_PRECEDENCE = 8;
171
172			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_ignore_space
173			const SQL_MODE_IGNORE_SPACE = 16;
174
175			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_auto_create_user
176			const SQL_MODE_NO_AUTO_CREATE_USER = 32;
177
178			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_auto_value_on_zero
179			const SQL_MODE_NO_AUTO_VALUE_ON_ZERO = 64;
180
181			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_backslash_escapes
182			const SQL_MODE_NO_BACKSLASH_ESCAPES = 128;
183
184			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_dir_in_create
185			const SQL_MODE_NO_DIR_IN_CREATE = 256;
186
187			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_dir_in_create
188			const SQL_MODE_NO_ENGINE_SUBSTITUTION = 512;
189
190			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_field_options
191			const SQL_MODE_NO_FIELD_OPTIONS = 1024;
192
193			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_key_options
194			const SQL_MODE_NO_KEY_OPTIONS = 2048;
195
196			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_table_options
197			const SQL_MODE_NO_TABLE_OPTIONS = 4096;
198
199			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_unsigned_subtraction
200			const SQL_MODE_NO_UNSIGNED_SUBTRACTION = 8192;
201
202			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_zero_date
203			const SQL_MODE_NO_ZERO_DATE = 16384;
204
205			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_no_zero_in_date
206			const SQL_MODE_NO_ZERO_IN_DATE = 32768;
207
208			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_only_full_group_by
209			const SQL_MODE_ONLY_FULL_GROUP_BY = 65536;
210
211			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_pipes_as_concat
212			const SQL_MODE_PIPES_AS_CONCAT = 131072;
213
214			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_real_as_float
215			const SQL_MODE_REAL_AS_FLOAT = 262144;
216
217			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_strict_all_tables
218			const SQL_MODE_STRICT_ALL_TABLES = 524288;
219
220			// https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sqlmode_strict_trans_tables
221			const SQL_MODE_STRICT_TRANS_TABLES = 1048576;
222
223			// Custom modes.
224
225			// The table and column names and any other field that must be escaped will
226			// not be.
227			// Reserved keywords are being escaped regardless this mode is used or not.
228			const SQL_MODE_NO_ENCLOSING_QUOTES = 1073741824;
229
230			/*
231			* Combination SQL Modes
232			* https://dev.mysql.com/doc/refman/5.0/en/sql-mode.html#sql-mode-combo
233			*/
234
235			// REAL_AS_FLOAT, PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE
236			const SQL_MODE_ANSI = 393234;
237
238			// PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
239			// NO_TABLE_OPTIONS, NO_FIELD_OPTIONS,
240			const SQL_MODE_DB2 = 138258;
241
242			// PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
243			// NO_TABLE_OPTIONS, NO_FIELD_OPTIONS, NO_AUTO_CREATE_USER
244			const SQL_MODE_MAXDB = 138290;
245
246			// PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
247			// NO_TABLE_OPTIONS, NO_FIELD_OPTIONS
248			const SQL_MODE_MSSQL = 138258;
249
250			// PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
251			// NO_TABLE_OPTIONS, NO_FIELD_OPTIONS, NO_AUTO_CREATE_USER
252			const SQL_MODE_ORACLE = 138290;
253
254			// PIPES_AS_CONCAT, ANSI_QUOTES, IGNORE_SPACE, NO_KEY_OPTIONS,
255			// NO_TABLE_OPTIONS, NO_FIELD_OPTIONS
256			const SQL_MODE_POSTGRESQL = 138258;
257
258			// STRICT_TRANS_TABLES, STRICT_ALL_TABLES, NO_ZERO_IN_DATE, NO_ZERO_DATE,
259			// ERROR_FOR_DIVISION_BY_ZERO, NO_AUTO_CREATE_USER
260			const SQL_MODE_TRADITIONAL = 1622052;
261
262			// -------------------------------------------------------------------------
263			// Keyword.
264
265			/**
266			* Checks if the given string is a keyword.
267			*
268			* @param string $str string to be checked
269			* @param bool $isReserved checks if the keyword is reserved
270			*
271			* @return int\|null
272			*/
273	468		public static function isKeyword($str, $isReserved = false)
274			{
275	468		$str = strtoupper($str);
276
277	468		if (isset(static::$KEYWORDS[$str])) {
278	452		if ($isReserved && ! (static::$KEYWORDS[$str] & Token::FLAG_KEYWORD_RESERVED)) {
279	1		return null;
280			}
281
282	452		return static::$KEYWORDS[$str];
283			}
284
285	466		return null;
286			}
287
288			// -------------------------------------------------------------------------
289			// Operator.
290
291			/**
292			* Checks if the given string is an operator.
293			*
294			* @param string $str string to be checked
295			*
296			* @return int\|null the appropriate flag for the operator
297			*/
298	476		public static function isOperator($str)
299			{
300	476		if (! isset(static::$OPERATORS[$str])) {
301	474		return null;
302			}
303
304	331		return static::$OPERATORS[$str];
305			}
306
307			// -------------------------------------------------------------------------
308			// Whitespace.
309
310			/**
311			* Checks if the given character is a whitespace.
312			*
313			* @param string $str string to be checked
314			*
315			* @return bool
316			*/
317	481		public static function isWhitespace($str)
318			{
319	481		return ($str === ' ') \|\| ($str === "\r") \|\| ($str === "\n") \|\| ($str === "\t");
320			}
321
322			// -------------------------------------------------------------------------
323			// Comment.
324
325			/**
326			* Checks if the given string is the beginning of a whitespace.
327			*
328			* @param string $str string to be checked
329			* @param mixed $end
330			*
331			* @return int\|null the appropriate flag for the comment type
332			*/
333	476		public static function isComment($str, $end = false)
334			{
335	476		$len = strlen($str);
336	476		if ($len === 0) {
337	1		return null;
338			}
339
340			// If comment is Bash style (#):
341	476		if ($str[0] === '#') {
342	4		return Token::FLAG_COMMENT_BASH;
343			}
344			// If comment is opening C style (/), warning, it could be a MySQL command (/!)
345	476		if (($len > 1) && ($str[0] === '/') && ($str[1] === '*')) {
346	32		return ($len > 2) && ($str[2] === '!') ?
347	32		Token::FLAG_COMMENT_MYSQL_CMD : Token::FLAG_COMMENT_C;
348			}
349			// If comment is closing C style (*/), warning, it could conflicts with wildcard and a real opening C style.
350			// It would looks like the following valid SQL statement: "SELECT / comment */ FROM...".
351	476		if (($len > 1) && ($str[0] === '*') && ($str[1] === '/')) {
352	4		return Token::FLAG_COMMENT_C;
353			}
354			// If comment is SQL style (--\s?):
355	476	View Code Duplication	if (($len > 2) && ($str[0] === '-')
356	476		&& ($str[1] === '-') && static::isWhitespace($str[2])
357			) {
358	19		return Token::FLAG_COMMENT_SQL;
359			}
360	476	View Code Duplication	if (($len === 2) && $end && ($str[0] === '-') && ($str[1] === '-')) {
361	1		return Token::FLAG_COMMENT_SQL;
362			}
363
364	476		return null;
365			}
366
367			// -------------------------------------------------------------------------
368			// Bool.
369
370			/**
371			* Checks if the given string is a boolean value.
372			* This actually check only for `TRUE` and `FALSE` because `1` or `0` are
373			* actually numbers and are parsed by specific methods.
374			*
375			* @param string $str string to be checked
376			*
377			* @return bool
378			*/
379	468		public static function isBool($str)
380			{
381	468		$str = strtoupper($str);
382
383	468		return ($str === 'TRUE') \|\| ($str === 'FALSE');
384			}
385
386			// -------------------------------------------------------------------------
387			// Number.
388
389			/**
390			* Checks if the given character can be a part of a number.
391			*
392			* @param string $str string to be checked
393			*
394			* @return bool
395			*/
396	1		public static function isNumber($str)
397			{
398	1		return (($str >= '0') && ($str <= '9')) \|\| ($str === '.')
399	1		\|\| ($str === '-') \|\| ($str === '+') \|\| ($str === 'e') \|\| ($str === 'E');
400			}
401
402			// -------------------------------------------------------------------------
403			// Symbol.
404
405			/**
406			* Checks if the given character is the beginning of a symbol. A symbol
407			* can be either a variable or a field name.
408			*
409			* @param string $str string to be checked
410			*
411			* @return int\|null the appropriate flag for the symbol type
412			*/
413	468		public static function isSymbol($str)
414			{
415	468		if (strlen($str) === 0) {
416	1		return null;
417			}
418	468		if ($str[0] === '@') {
419	32		return Token::FLAG_SYMBOL_VARIABLE;
420	467		} elseif ($str[0] === '`') {
421	109		return Token::FLAG_SYMBOL_BACKTICK;
422	467		} elseif ($str[0] === ':' \|\| $str[0] === '?') {
423	3		return Token::FLAG_SYMBOL_PARAMETER;
424			}
425
426	467		return null;
427			}
428
429			// -------------------------------------------------------------------------
430			// String.
431
432			/**
433			* Checks if the given character is the beginning of a string.
434			*
435			* @param string $str string to be checked
436			*
437			* @return int\|null the appropriate flag for the string type
438			*/
439	468		public static function isString($str)
440			{
441	468		if (strlen($str) === 0) {
442	1		return null;
443			}
444	468		if ($str[0] === '\'') {
445	92		return Token::FLAG_STRING_SINGLE_QUOTES;
446	468		} elseif ($str[0] === '"') {
447	63		return Token::FLAG_STRING_DOUBLE_QUOTES;
448			}
449
450	468		return null;
451			}
452
453			// -------------------------------------------------------------------------
454			// Delimiter.
455
456			/**
457			* Checks if the given character can be a separator for two lexeme.
458			*
459			* @param string $str string to be checked
460			*
461			* @return bool
462			*/
463	468		public static function isSeparator($str)
464			{
465			// NOTES: Only non alphanumeric ASCII characters may be separators.
466			// `~` is the last printable ASCII character.
467	468		return ($str <= '~') && ($str !== '_')
468	468		&& (($str < '0') \|\| ($str > '9'))
469	468		&& (($str < 'a') \|\| ($str > 'z'))
470	468		&& (($str < 'A') \|\| ($str > 'Z'));
471			}
472
473			/**
474			* Loads the specified context.
475			*
476			* Contexts may be used by accessing the context directly.
477			*
478			* @param string $context name of the context or full class name that
479			* defines the context
480			*
481			* @throws LoaderException if the specified context doesn't exist
482			*/
483	21		public static function load($context = '')
484			{
485	21		if (empty($context)) {
486	18		$context = self::$defaultContext;
487			}
488	21		if ($context[0] !== '\\') {
489			// Short context name (must be formatted into class name).
490	20		$context = self::$contextPrefix . $context;
491			}
492	21		if (! class_exists($context)) {
493	6		throw @new LoaderException(
494	6		'Specified context ("' . $context . '") does not exist.',
495			$context
496			);
497			}
498	20		self::$loadedContext = $context;
499	20		self::$KEYWORDS = $context::$KEYWORDS;
500	20		}
501
502			/**
503			* Loads the context with the closest version to the one specified.
504			*
505			* The closest context is found by replacing last digits with zero until one
506			* is loaded successfully.
507			*
508			* @see Context::load()
509			*
510			* @param string $context name of the context or full class name that
511			* defines the context
512			*
513			* @return string\|null The loaded context. `null` if no context was loaded.
514			*/
515	7		public static function loadClosest($context = '')
516			{
517	7		$length = strlen($context);
518	7		for ($i = $length; $i > 0;) {
519			try {
520			/* Trying to load the new context */
521	7		static::load($context);
522	6		return $context;
523	5		} catch (LoaderException $e) {
524			/* Replace last two non zero digits by zeroes */
525			do {
526	5		$i -= 2;
527	5		$part = substr($context, $i, 2);
528			/* No more numeric parts to strip */
529	5		if (! is_numeric($part)) {
530	3		break 2;
531			}
532	4		} while (intval($part) === 0 && $i > 0);
533	4		$context = substr($context, 0, $i) . '00' . substr($context, $i + 2);
534			}
535			}
536			/* Fallback to loading at least matching engine */
537	3		if (strncmp($context, 'MariaDb', 7) === 0) {
538	1		return static::loadClosest('MariaDb100300');
539	2		} elseif (strncmp($context, 'MySql', 5) === 0) {
540	1		return static::loadClosest('MySql50700');
541			}
542	1		return null;
543			}
544
545			/**
546			* Sets the SQL mode.
547			*
548			* @param string $mode The list of modes. If empty, the mode is reset.
549			*/
550	262		public static function setMode($mode = '')
551			{
552	262		static::$MODE = 0;
553	262		if (empty($mode)) {
554	262		return;
555			}
556	2		$mode = explode(',', $mode);
557	2		foreach ($mode as $m) {
558	2		static::$MODE \|= constant('static::SQL_MODE_' . $m);
559			}
560	2		}
561
562			/**
563			* Escapes the symbol by adding surrounding backticks.
564			*
565			* @param array\|string $str the string to be escaped
566			* @param string $quote quote to be used when escaping
567			*
568			* @return string\|array
569			*/
570	39		public static function escape($str, $quote = '`')
571			{
572	39		if (is_array($str)) {
573	12		foreach ($str as $key => $value) {
574	12		$str[$key] = static::escape($value);
575			}
576
577	12		return $str;
578			}
579
580	39		if ((static::$MODE & self::SQL_MODE_NO_ENCLOSING_QUOTES)
581	39		&& (! static::isKeyword($str, true))
			0 ignored issues – show Bug Best Practice introduced 2020-02-10 19:35 UTC by Report Bug Copy Issue Report The expression `static::isKeyword($str, true)` of type `integer\|null` is loosely compared to `false`; this is ambiguous if the integer can be zero. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
582			) {
583	1		return $str;
584			}
585
586	39		if (static::$MODE & self::SQL_MODE_ANSI_QUOTES) {
587	1		$quote = '"';
588			}
589
590	39		return $quote . str_replace($quote, $quote . $quote, $str) . $quote;
591			}
592
593			/**
594			* Returns char used to quote identifiers based on currently set SQL Mode (ie. standard or ANSI_QUOTES)
595			* @return string either " (double quote, ansi_quotes mode) or ` (backtick, standard mode)
596			*/
597			public static function getIdentifierQuote()
598			{
599			return self::hasMode(self::SQL_MODE_ANSI_QUOTES) ? '"' : '`';
600			}
601
602			/**
603			* Function verifies that given SQL Mode constant is currently set
604			*
605			* @return boolean false on empty param, true/false on given constant/int value
606			* @param int $flag for example Context::SQL_MODE_ANSI_QUOTES
			0 ignored issues – show Documentation introduced 2020-03-06 13:10 UTC by Report Bug Copy Issue Report Should the type for parameter `$flag` not be `integer\|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...
607			*/
608			public static function hasMode($flag = null)
609			{
610			if (empty($flag)) {
611			return false;
612			}
613			return (self::$MODE & $flag) === $flag;
614			}
615			}
616
617			// Initializing the default context.
618			Context::load();
619

phpmyadmin / sql-parser