CreateStatement - Code Metrics - Inspection of "Update CreateStatement.php" - phpmyadmin/sql-parser - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#175)

unknown

created 2017-10-10 10:48 UTC

CreateStatement D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	606
Duplicated Lines	2.31 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

88.63%

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	77
lcom	1
cbo	12
dl	14
loc	606
ccs	187
cts	211
cp	0.8863
rs	4.8477
c	1
b	0
f	0

2 Methods

Rating	Name	Duplication	Size	Complexity
D	build()	0	83	20
F	parse()	14	278	57

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 CreateStatement 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 CreateStatement, and based on these observations, apply Extract Interface, too.

<?php

/**
 * `CREATE` statement.
 */

namespace PhpMyAdmin\SqlParser\Statements;

use PhpMyAdmin\SqlParser\Components\ArrayObj;
use PhpMyAdmin\SqlParser\Components\CreateDefinition;
use PhpMyAdmin\SqlParser\Components\DataType;
use PhpMyAdmin\SqlParser\Components\Expression;
use PhpMyAdmin\SqlParser\Components\OptionsArray;
use PhpMyAdmin\SqlParser\Components\ParameterDefinition;
use PhpMyAdmin\SqlParser\Components\PartitionDefinition;
use PhpMyAdmin\SqlParser\Parser;
use PhpMyAdmin\SqlParser\Statement;
use PhpMyAdmin\SqlParser\Token;
use PhpMyAdmin\SqlParser\TokensList;

/**
 * `CREATE` statement.
 *
 * @category   Statements
 *
 * @license    https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
 */
class CreateStatement extends Statement
{
    /**
     * Options for `CREATE` statements.
     *
     * @var array
     */
    public static $OPTIONS = array(
        // CREATE TABLE
        'TEMPORARY' => 1,

        // CREATE VIEW
        'OR REPLACE' => array(2, 'var='),
        'ALGORITHM' => array(3, 'var='),
        // `DEFINER` is also used for `CREATE FUNCTION / PROCEDURE`
        'DEFINER' => array(4, 'expr='),
        'SQL SECURITY' => array(5, 'var'),

        'DATABASE' => 6,
        'EVENT' => 6,
        'FUNCTION' => 6,
        'INDEX' => 6,
        'UNIQUE INDEX' => 6,
        'FULLTEXT INDEX' => 6,
        'SPATIAL INDEX' => 6,
        'PROCEDURE' => 6,
        'SERVER' => 6,
        'TABLE' => 6,
        'TABLESPACE' => 6,
        'TRIGGER' => 6,
        'USER' => 6,
        'VIEW' => 6,

        // CREATE TABLE
        'IF NOT EXISTS' => 7,
    );

    /**
     * All database options.
     *
     * @var array
     */
    public static $DB_OPTIONS = array(
        'CHARACTER SET' => array(1, 'var='),
        'CHARSET' => array(1, 'var='),
        'DEFAULT CHARACTER SET' => array(1, 'var='),
        'DEFAULT CHARSET' => array(1, 'var='),
        'DEFAULT COLLATE' => array(2, 'var='),
        'COLLATE' => array(2, 'var='),
    );

    /**
     * All table options.
     *
     * @var array
     */
    public static $TABLE_OPTIONS = array(
        'ENGINE' => array(1, 'var='),
        'AUTO_INCREMENT' => array(2, 'var='),
        'AVG_ROW_LENGTH' => array(3, 'var'),
        'CHARACTER SET' => array(4, 'var='),
        'CHARSET' => array(4, 'var='),
        'DEFAULT CHARACTER SET' => array(4, 'var='),
        'DEFAULT CHARSET' => array(4, 'var='),
        'CHECKSUM' => array(5, 'var'),
        'DEFAULT COLLATE' => array(6, 'var='),
        'COLLATE' => array(6, 'var='),
        'COMMENT' => array(7, 'var='),
        'CONNECTION' => array(8, 'var'),
        'DATA DIRECTORY' => array(9, 'var'),
        'DELAY_KEY_WRITE' => array(10, 'var'),
        'INDEX DIRECTORY' => array(11, 'var'),
        'INSERT_METHOD' => array(12, 'var'),
        'KEY_BLOCK_SIZE' => array(13, 'var'),
        'MAX_ROWS' => array(14, 'var'),
        'MIN_ROWS' => array(15, 'var'),
        'PACK_KEYS' => array(16, 'var'),
        'PASSWORD' => array(17, 'var'),
        'ROW_FORMAT' => array(18, 'var'),
        'TABLESPACE' => array(19, 'var'),
        'STORAGE' => array(20, 'var'),
        'UNION' => array(21, 'var'),
    );

    /**
     * All function options.
     *
     * @var array
     */
    public static $FUNC_OPTIONS = array(
        'COMMENT' => array(1, 'var='),
        'LANGUAGE SQL' => 2,
        'DETERMINISTIC' => 3,
        'NOT DETERMINISTIC' => 3,
        'CONTAINS SQL' => 4,
        'NO SQL' => 4,
        'READS SQL DATA' => 4,
        'MODIFIES SQL DATA' => 4,
        'SQL SECURITY DEFINER' => array(5, 'var'),
    );

    /**
     * All trigger options.
     *
     * @var array
     */
    public static $TRIGGER_OPTIONS = array(
        'BEFORE' => 1,
        'AFTER' => 1,
        'INSERT' => 2,
        'UPDATE' => 2,
        'DELETE' => 2,
    );

    /**
     * The name of the entity that is created.
     *
     * Used by all `CREATE` statements.
     *
     * @var Expression
     */
    public $name;

    /**
     * The options of the entity (table, procedure, function, etc.).
     *
     * Used by `CREATE TABLE`, `CREATE FUNCTION` and `CREATE PROCEDURE`.
     *
     * @var OptionsArray
     *
     * @see static::$TABLE_OPTIONS
     * @see static::$FUNC_OPTIONS
     * @see static::$TRIGGER_OPTIONS
     */
    public $entityOptions;

    /**
     * If `CREATE TABLE`, a list of columns and keys.
     * If `CREATE VIEW`, a list of columns.
     *
     * Used by `CREATE TABLE` and `CREATE VIEW`.
     *
     * @var CreateDefinition[]|ArrayObj
     */
    public $fields;

    /**
     * If `CREATE TABLE ... SELECT`.
     *
     * Used by `CREATE TABLE`
     *
     * @var SelectStatement
     */
    public $select;

    /**
     * If `CREATE TABLE ... LIKE`.
     *
     * Used by `CREATE TABLE`
     *
     * @var Expression
     */
    public $like;

    /**
     * Expression used for partitioning.
     *
     * @var string
     */
    public $partitionBy;

    /**
     * The number of partitions.
     *
     * @var int
     */
    public $partitionsNum;

    /**
     * Expression used for subpartitioning.
     *
     * @var string
     */
    public $subpartitionBy;

    /**
     * The number of subpartitions.
     *
     * @var int
     */
    public $subpartitionsNum;

    /**
     * The partition of the new table.
     *
     * @var PartitionDefinition[]
     */
    public $partitions;

    /**
     * If `CREATE TRIGGER` the name of the table.
     *
     * Used by `CREATE TRIGGER`.
     *
     * @var Expression
     */
    public $table;

    /**
     * The return data type of this routine.
     *
     * Used by `CREATE FUNCTION`.
     *
     * @var DataType
     */
    public $return;

    /**
     * The parameters of this routine.
     *
     * Used by `CREATE FUNCTION` and `CREATE PROCEDURE`.
     *
     * @var ParameterDefinition[]
     */
    public $parameters;

    /**
     * The body of this function or procedure. For views, it is the select
     * statement that gets the.
     *
     * Used by `CREATE FUNCTION`, `CREATE PROCEDURE` and `CREATE VIEW`.
     *
     * @var Token[]|string
     */
    public $body = array();

    /**
     * @return string
     */
    public function build()
    {
        $fields = '';
        if (!empty($this->fields)) {
            if (is_array($this->fields)) {
                $fields = CreateDefinition::build($this->fields) . ' ';
            } elseif ($this->fields instanceof ArrayObj) {
                $fields = ArrayObj::build($this->fields);
            }
        }
        if ($this->options->has('DATABASE')) {
            return 'CREATE '
                . OptionsArray::build($this->options) . ' '
                . Expression::build($this->name) . ' '
                . OptionsArray::build($this->entityOptions);
        } elseif ($this->options->has('TABLE') && !is_null($this->select)) {
            return 'CREATE '
                . OptionsArray::build($this->options) . ' '
                . Expression::build($this->name) . ' '
                . $this->select->build();
        } elseif ($this->options->has('TABLE') && !is_null($this->like)) {
            return 'CREATE '
                . OptionsArray::build($this->options) . ' '
                . Expression::build($this->name) . ' LIKE '
                . Expression::build($this->like);
        } elseif ($this->options->has('TABLE')) {
            $partition = '';

            if (!empty($this->partitionBy)) {
                $partition .= "\nPARTITION BY " . $this->partitionBy;
            }
            if (!empty($this->partitionsNum)) {
                $partition .= "\nPARTITIONS " . $this->partitionsNum;
            }
            if (!empty($this->subpartitionBy)) {
                $partition .= "\nSUBPARTITION BY " . $this->subpartitionBy;
            }
            if (!empty($this->subpartitionsNum)) {
                $partition .= "\nSUBPARTITIONS " . $this->subpartitionsNum;
            }
            if (!empty($this->partitions)) {
                $partition .= "\n" . PartitionDefinition::build($this->partitions);
            }

            return 'CREATE '
                . OptionsArray::build($this->options) . ' '
                . Expression::build($this->name) . ' '
                . $fields
                . OptionsArray::build($this->entityOptions)
                . $partition;
        } elseif ($this->options->has('VIEW')) {
            return 'CREATE '
                . OptionsArray::build($this->options) . ' '
                . Expression::build($this->name) . ' '
                . $fields . ' AS ' . TokensList::build($this->body) . ' '
                . OptionsArray::build($this->entityOptions);
        } elseif ($this->options->has('TRIGGER')) {
            return 'CREATE '
                . OptionsArray::build($this->options) . ' '
                . Expression::build($this->name) . ' '
                . OptionsArray::build($this->entityOptions) . ' '
                . 'ON ' . Expression::build($this->table) . ' '
                . 'FOR EACH ROW ' . TokensList::build($this->body);
        } elseif (($this->options->has('PROCEDURE'))
            || ($this->options->has('FUNCTION'))
        ) {
            $tmp = '';
            if ($this->options->has('FUNCTION')) {
                $tmp = 'RETURNS ' . DataType::build($this->return);
            }

            return 'CREATE '
                . OptionsArray::build($this->options) . ' '
                . Expression::build($this->name) . ' '
                . ParameterDefinition::build($this->parameters) . ' '
                . $tmp . ' ' . TokensList::build($this->body);
        }

        return 'CREATE '
            . OptionsArray::build($this->options) . ' '
            . Expression::build($this->name) . ' '
            . TokensList::build($this->body);
    }

    /**
     * @param Parser     $parser the instance that requests parsing
     * @param TokensList $list   the list of tokens to be parsed
     */
    public function parse(Parser $parser, TokensList $list)
    {
        ++$list->idx; // Skipping `CREATE`.

        // Parsing options.
        $this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
        ++$list->idx; // Skipping last option.

        // Parsing the field name.
        $this->name = Expression::parse(
            $parser,
            $list,
            array(
                'parseField' => 'table',
                'breakOnAlias' => true,
            )
        );

        if ((!isset($this->name)) || ($this->name === '')) {
            $parser->error(
                'The name of the entity was expected.',
                $list->tokens[$list->idx]
            );
        } else {
            ++$list->idx; // Skipping field.
        }

        /**
         * Token parsed at this moment.
         *
         * @var Token
         */
        $token = $list->tokens[$list->idx];
        $nextidx = $list->idx + 1;
        while ($nextidx < $list->count && $list->tokens[$nextidx]->type == Token::TYPE_WHITESPACE) {
            ++$nextidx;
        }

        if ($this->options->has('DATABASE')) {
            $this->entityOptions = OptionsArray::parse(
                $parser,
                $list,
                static::$DB_OPTIONS
            );
        } elseif ($this->options->has('TABLE')
            && ($token->type == Token::TYPE_KEYWORD)
            && ($token->keyword == 'SELECT')
        ) {
            /* CREATE TABLE ... SELECT */
            $this->select = new SelectStatement($parser, $list);
        } elseif ($this->options->has('TABLE')
            && ($token->type == Token::TYPE_KEYWORD) && ($token->keyword == 'AS')
            && ($list->tokens[$nextidx]->type == Token::TYPE_KEYWORD)
            && ($list->tokens[$nextidx]->value == 'SELECT')
        ) {
            /* CREATE TABLE ... AS SELECT */
            $list->idx = $nextidx;
            $this->select = new SelectStatement($parser, $list);
        } elseif ($this->options->has('TABLE')
            && $token->type == Token::TYPE_KEYWORD
            && $token->keyword == 'LIKE'
        ) {
            /* CREATE TABLE `new_tbl` LIKE 'orig_tbl' */
            $list->idx = $nextidx;
            $this->like = Expression::parse(
                $parser,
                $list,
                array(
                    'parseField' => 'table',
                    'breakOnAlias' => true,
                )
            );
            // The 'LIKE' keyword was found, but no table_name was found next to it
            if ($this->like == null) {
                $parser->error(
                    'A table name was expected.',
                    $list->tokens[$list->idx]
                );
            }
        } elseif ($this->options->has('TABLE')) {
            $this->fields = CreateDefinition::parse($parser, $list);
            if (empty($this->fields)) {
                $parser->error(
                    'At least one column definition was expected.',
                    $list->tokens[$list->idx]
                );
            }
            ++$list->idx;

            $this->entityOptions = OptionsArray::parse(
                $parser,
                $list,
                static::$TABLE_OPTIONS
            );

            /**
             * The field that is being filled (`partitionBy` or
             * `subpartitionBy`).
             *
             * @var string
             */
            $field = null;

            /**
             * The number of brackets. `false` means no bracket was found
             * previously. At least one bracket is required to validate the
             * expression.
             *
             * @var int|bool
             */
            $brackets = false;

            /*
             * Handles partitions.
             */
            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 comments.
                if ($token->type === Token::TYPE_COMMENT) {
                    continue;
                }

                if (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'PARTITION BY')) {
                    $field = 'partitionBy';
                    $brackets = false;
                } elseif (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'SUBPARTITION BY')) {
                    $field = 'subpartitionBy';
                    $brackets = false;
                } elseif (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'PARTITIONS')) {
                    $token = $list->getNextOfType(Token::TYPE_NUMBER);
                    --$list->idx; // `getNextOfType` also advances one position.
                    $this->partitionsNum = $token->value;
                } elseif (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'SUBPARTITIONS')) {
                    $token = $list->getNextOfType(Token::TYPE_NUMBER);
                    --$list->idx; // `getNextOfType` also advances one position.
                    $this->subpartitionsNum = $token->value;
                } elseif (!empty($field)) {
                    /*
                     * Handling the content of `PARTITION BY` and `SUBPARTITION BY`.
                     */

                    // Counting brackets.
                    if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
                        // This is used instead of `++$brackets` because,
                        // initially, `$brackets` is `false` cannot be
                        // incremented.
                        $brackets = $brackets + 1;
                    } elseif (($token->type === Token::TYPE_OPERATOR) && ($token->value === ')')) {
                        --$brackets;
                    }

                    // Building the expression used for partitioning.
                    $this->field .= ($token->type === Token::TYPE_WHITESPACE) ? ' ' : $token->token;


                    // Last bracket was read, the expression ended.
                    // Comparing with `0` and not `false`, because `false` means
                    // that no bracket was found and at least one must is
                    // required.
                    if ($brackets === 0) {
                        $this->field = trim($this->field);

                        $field = null;
                    }
                } elseif (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
                    if (!empty($this->partitionBy)) {
                        $this->partitions = ArrayObj::parse(
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
                            $parser,
                            $list,
                            array(
                                'type' => 'PhpMyAdmin\\SqlParser\\Components\\PartitionDefinition',
                            )
                        );
                    }
                    break;
                }
            }
        } elseif (($this->options->has('PROCEDURE'))
            || ($this->options->has('FUNCTION'))
        ) {
            $this->parameters = ParameterDefinition::parse($parser, $list);
            if ($this->options->has('FUNCTION')) {
                $prev_token = $token;
                $token = $list->getNextOfType(Token::TYPE_KEYWORD);
                if (is_null($token) || $token->keyword !== 'RETURNS') {
                    $parser->error(
                        'A "RETURNS" keyword was expected.',
                        is_null($token) ? $prev_token : $token
                    );
                } else {
                    ++$list->idx;
                    $this->return = DataType::parse(
                        $parser,
                        $list
                    );
                }
            }
            ++$list->idx;

            $this->entityOptions = OptionsArray::parse(
                $parser,
                $list,
                static::$FUNC_OPTIONS
            );
            ++$list->idx;

            for (; $list->idx < $list->count; ++$list->idx) {
                $token = $list->tokens[$list->idx];
                $this->body[] = $token;
            }
        } elseif ($this->options->has('VIEW')) {
            $token = $list->getNext(); // Skipping whitespaces and comments.

            // Parsing columns list.
            if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
                --$list->idx; // getNext() also goes forward one field.
                $this->fields = ArrayObj::parse($parser, $list);
                ++$list->idx; // Skipping last token from the array.
                $list->getNext();
            }

            // Parsing the `AS` keyword.
            for (; $list->idx < $list->count; ++$list->idx) {
                $token = $list->tokens[$list->idx];
                if ($token->type === Token::TYPE_DELIMITER) {
                    break;
                }
                $this->body[] = $token;
            }
        } elseif ($this->options->has('TRIGGER')) {
            // Parsing the time and the event.
            $this->entityOptions = OptionsArray::parse(
                $parser,
                $list,
                static::$TRIGGER_OPTIONS
            );
            ++$list->idx;

            $list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'ON');
            ++$list->idx; // Skipping `ON`.

            // Parsing the name of the table.
            $this->table = Expression::parse(
                $parser,
                $list,
                array(
                    'parseField' => 'table',
                    'breakOnAlias' => true,
                )
            );
            ++$list->idx;

            $list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'FOR EACH ROW');
            ++$list->idx; // Skipping `FOR EACH ROW`.

            for (; $list->idx < $list->count; ++$list->idx) {
                $token = $list->tokens[$list->idx];
                $this->body[] = $token;
            }
        } else {
            for (; $list->idx < $list->count; ++$list->idx) {
                $token = $list->tokens[$list->idx];
                if ($token->type === Token::TYPE_DELIMITER) {
                    break;
                }
                $this->body[] = $token;
            }
        }
    }
}


1			<?php
2
3			/**
4			* `CREATE` statement.
5			*/
6
7			namespace PhpMyAdmin\SqlParser\Statements;
8
9			use PhpMyAdmin\SqlParser\Components\ArrayObj;
10			use PhpMyAdmin\SqlParser\Components\CreateDefinition;
11			use PhpMyAdmin\SqlParser\Components\DataType;
12			use PhpMyAdmin\SqlParser\Components\Expression;
13			use PhpMyAdmin\SqlParser\Components\OptionsArray;
14			use PhpMyAdmin\SqlParser\Components\ParameterDefinition;
15			use PhpMyAdmin\SqlParser\Components\PartitionDefinition;
16			use PhpMyAdmin\SqlParser\Parser;
17			use PhpMyAdmin\SqlParser\Statement;
18			use PhpMyAdmin\SqlParser\Token;
19			use PhpMyAdmin\SqlParser\TokensList;
20
21			/**
22			* `CREATE` statement.
23			*
24			* @category Statements
25			*
26			* @license https://www.gnu.org/licenses/gpl-2.0.txt GPL-2.0+
27			*/
28			class CreateStatement extends Statement
29			{
30			/**
31			* Options for `CREATE` statements.
32			*
33			* @var array
34			*/
35			public static $OPTIONS = array(
36			// CREATE TABLE
37			'TEMPORARY' => 1,
38
39			// CREATE VIEW
40			'OR REPLACE' => array(2, 'var='),
41			'ALGORITHM' => array(3, 'var='),
42			// `DEFINER` is also used for `CREATE FUNCTION / PROCEDURE`
43			'DEFINER' => array(4, 'expr='),
44			'SQL SECURITY' => array(5, 'var'),
45
46			'DATABASE' => 6,
47			'EVENT' => 6,
48			'FUNCTION' => 6,
49			'INDEX' => 6,
50			'UNIQUE INDEX' => 6,
51			'FULLTEXT INDEX' => 6,
52			'SPATIAL INDEX' => 6,
53			'PROCEDURE' => 6,
54			'SERVER' => 6,
55			'TABLE' => 6,
56			'TABLESPACE' => 6,
57			'TRIGGER' => 6,
58			'USER' => 6,
59			'VIEW' => 6,
60
61			// CREATE TABLE
62			'IF NOT EXISTS' => 7,
63			);
64
65			/**
66			* All database options.
67			*
68			* @var array
69			*/
70			public static $DB_OPTIONS = array(
71			'CHARACTER SET' => array(1, 'var='),
72			'CHARSET' => array(1, 'var='),
73			'DEFAULT CHARACTER SET' => array(1, 'var='),
74			'DEFAULT CHARSET' => array(1, 'var='),
75			'DEFAULT COLLATE' => array(2, 'var='),
76			'COLLATE' => array(2, 'var='),
77			);
78
79			/**
80			* All table options.
81			*
82			* @var array
83			*/
84			public static $TABLE_OPTIONS = array(
85			'ENGINE' => array(1, 'var='),
86			'AUTO_INCREMENT' => array(2, 'var='),
87			'AVG_ROW_LENGTH' => array(3, 'var'),
88			'CHARACTER SET' => array(4, 'var='),
89			'CHARSET' => array(4, 'var='),
90			'DEFAULT CHARACTER SET' => array(4, 'var='),
91			'DEFAULT CHARSET' => array(4, 'var='),
92			'CHECKSUM' => array(5, 'var'),
93			'DEFAULT COLLATE' => array(6, 'var='),
94			'COLLATE' => array(6, 'var='),
95			'COMMENT' => array(7, 'var='),
96			'CONNECTION' => array(8, 'var'),
97			'DATA DIRECTORY' => array(9, 'var'),
98			'DELAY_KEY_WRITE' => array(10, 'var'),
99			'INDEX DIRECTORY' => array(11, 'var'),
100			'INSERT_METHOD' => array(12, 'var'),
101			'KEY_BLOCK_SIZE' => array(13, 'var'),
102			'MAX_ROWS' => array(14, 'var'),
103			'MIN_ROWS' => array(15, 'var'),
104			'PACK_KEYS' => array(16, 'var'),
105			'PASSWORD' => array(17, 'var'),
106			'ROW_FORMAT' => array(18, 'var'),
107			'TABLESPACE' => array(19, 'var'),
108			'STORAGE' => array(20, 'var'),
109			'UNION' => array(21, 'var'),
110			);
111
112			/**
113			* All function options.
114			*
115			* @var array
116			*/
117			public static $FUNC_OPTIONS = array(
118			'COMMENT' => array(1, 'var='),
119			'LANGUAGE SQL' => 2,
120			'DETERMINISTIC' => 3,
121			'NOT DETERMINISTIC' => 3,
122			'CONTAINS SQL' => 4,
123			'NO SQL' => 4,
124			'READS SQL DATA' => 4,
125			'MODIFIES SQL DATA' => 4,
126			'SQL SECURITY DEFINER' => array(5, 'var'),
127			);
128
129			/**
130			* All trigger options.
131			*
132			* @var array
133			*/
134			public static $TRIGGER_OPTIONS = array(
135			'BEFORE' => 1,
136			'AFTER' => 1,
137			'INSERT' => 2,
138			'UPDATE' => 2,
139			'DELETE' => 2,
140			);
141
142			/**
143			* The name of the entity that is created.
144			*
145			* Used by all `CREATE` statements.
146			*
147			* @var Expression
148			*/
149			public $name;
150
151			/**
152			* The options of the entity (table, procedure, function, etc.).
153			*
154			* Used by `CREATE TABLE`, `CREATE FUNCTION` and `CREATE PROCEDURE`.
155			*
156			* @var OptionsArray
157			*
158			* @see static::$TABLE_OPTIONS
159			* @see static::$FUNC_OPTIONS
160			* @see static::$TRIGGER_OPTIONS
161			*/
162			public $entityOptions;
163
164			/**
165			* If `CREATE TABLE`, a list of columns and keys.
166			* If `CREATE VIEW`, a list of columns.
167			*
168			* Used by `CREATE TABLE` and `CREATE VIEW`.
169			*
170			* @var CreateDefinition[]\|ArrayObj
171			*/
172			public $fields;
173
174			/**
175			* If `CREATE TABLE ... SELECT`.
176			*
177			* Used by `CREATE TABLE`
178			*
179			* @var SelectStatement
180			*/
181			public $select;
182
183			/**
184			* If `CREATE TABLE ... LIKE`.
185			*
186			* Used by `CREATE TABLE`
187			*
188			* @var Expression
189			*/
190			public $like;
191
192			/**
193			* Expression used for partitioning.
194			*
195			* @var string
196			*/
197			public $partitionBy;
198
199			/**
200			* The number of partitions.
201			*
202			* @var int
203			*/
204			public $partitionsNum;
205
206			/**
207			* Expression used for subpartitioning.
208			*
209			* @var string
210			*/
211			public $subpartitionBy;
212
213			/**
214			* The number of subpartitions.
215			*
216			* @var int
217			*/
218			public $subpartitionsNum;
219
220			/**
221			* The partition of the new table.
222			*
223			* @var PartitionDefinition[]
224			*/
225			public $partitions;
226
227			/**
228			* If `CREATE TRIGGER` the name of the table.
229			*
230			* Used by `CREATE TRIGGER`.
231			*
232			* @var Expression
233			*/
234			public $table;
235
236			/**
237			* The return data type of this routine.
238			*
239			* Used by `CREATE FUNCTION`.
240			*
241			* @var DataType
242			*/
243			public $return;
244
245			/**
246			* The parameters of this routine.
247			*
248			* Used by `CREATE FUNCTION` and `CREATE PROCEDURE`.
249			*
250			* @var ParameterDefinition[]
251			*/
252			public $parameters;
253
254			/**
255			* The body of this function or procedure. For views, it is the select
256			* statement that gets the.
257			*
258			* Used by `CREATE FUNCTION`, `CREATE PROCEDURE` and `CREATE VIEW`.
259			*
260			* @var Token[]\|string
261			*/
262			public $body = array();
263
264			/**
265			* @return string
266			*/
267	9		public function build()
268			{
269	9		$fields = '';
270	9		if (!empty($this->fields)) {
271	4		if (is_array($this->fields)) {
272	3		$fields = CreateDefinition::build($this->fields) . ' ';
273	1		} elseif ($this->fields instanceof ArrayObj) {
274	1		$fields = ArrayObj::build($this->fields);
275			}
276			}
277	9		if ($this->options->has('DATABASE')) {
278			return 'CREATE '
279	1		. OptionsArray::build($this->options) . ' '
280	1		. Expression::build($this->name) . ' '
281	1		. OptionsArray::build($this->entityOptions);
282	8		} elseif ($this->options->has('TABLE') && !is_null($this->select)) {
283			return 'CREATE '
284	1		. OptionsArray::build($this->options) . ' '
285	1		. Expression::build($this->name) . ' '
286	1		. $this->select->build();
287	7		} elseif ($this->options->has('TABLE') && !is_null($this->like)) {
288			return 'CREATE '
289	1		. OptionsArray::build($this->options) . ' '
290	1		. Expression::build($this->name) . ' LIKE '
291	1		. Expression::build($this->like);
292	7		} elseif ($this->options->has('TABLE')) {
293	3		$partition = '';
294
295	3		if (!empty($this->partitionBy)) {
296			$partition .= "\nPARTITION BY " . $this->partitionBy;
297			}
298	3		if (!empty($this->partitionsNum)) {
299			$partition .= "\nPARTITIONS " . $this->partitionsNum;
300			}
301	3		if (!empty($this->subpartitionBy)) {
302			$partition .= "\nSUBPARTITION BY " . $this->subpartitionBy;
303			}
304	3		if (!empty($this->subpartitionsNum)) {
305			$partition .= "\nSUBPARTITIONS " . $this->subpartitionsNum;
306			}
307	3		if (!empty($this->partitions)) {
308			$partition .= "\n" . PartitionDefinition::build($this->partitions);
309			}
310
311			return 'CREATE '
312	3		. OptionsArray::build($this->options) . ' '
313	3		. Expression::build($this->name) . ' '
314	3		. $fields
315	3		. OptionsArray::build($this->entityOptions)
316	3		. $partition;
317	4		} elseif ($this->options->has('VIEW')) {
318			return 'CREATE '
319	1		. OptionsArray::build($this->options) . ' '
320	1		. Expression::build($this->name) . ' '
321	1		. $fields . ' AS ' . TokensList::build($this->body) . ' '
322	1		. OptionsArray::build($this->entityOptions);
323	3		} elseif ($this->options->has('TRIGGER')) {
324			return 'CREATE '
325	1		. OptionsArray::build($this->options) . ' '
326	1		. Expression::build($this->name) . ' '
327	1		. OptionsArray::build($this->entityOptions) . ' '
328	1		. 'ON ' . Expression::build($this->table) . ' '
329	1		. 'FOR EACH ROW ' . TokensList::build($this->body);
330	2		} elseif (($this->options->has('PROCEDURE'))
331	2		\|\| ($this->options->has('FUNCTION'))
332			) {
333	1		$tmp = '';
334	1		if ($this->options->has('FUNCTION')) {
335	1		$tmp = 'RETURNS ' . DataType::build($this->return);
336			}
337
338			return 'CREATE '
339	1		. OptionsArray::build($this->options) . ' '
340	1		. Expression::build($this->name) . ' '
341	1		. ParameterDefinition::build($this->parameters) . ' '
342	1		. $tmp . ' ' . TokensList::build($this->body);
343			}
344
345			return 'CREATE '
346	1		. OptionsArray::build($this->options) . ' '
347	1		. Expression::build($this->name) . ' '
348	1		. TokensList::build($this->body);
349			}
350
351			/**
352			* @param Parser $parser the instance that requests parsing
353			* @param TokensList $list the list of tokens to be parsed
354			*/
355	53		public function parse(Parser $parser, TokensList $list)
356			{
357	53		++$list->idx; // Skipping `CREATE`.
358
359			// Parsing options.
360	53		$this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
361	53		++$list->idx; // Skipping last option.
362
363			// Parsing the field name.
364	53		$this->name = Expression::parse(
365	53		$parser,
366	53		$list,
367			array(
368	53		'parseField' => 'table',
369			'breakOnAlias' => true,
370			)
371			);
372
373	53		if ((!isset($this->name)) \|\| ($this->name === '')) {
374	1		$parser->error(
375	1		'The name of the entity was expected.',
376	1		$list->tokens[$list->idx]
377			);
378			} else {
379	52		++$list->idx; // Skipping field.
380			}
381
382			/**
383			* Token parsed at this moment.
384			*
385			* @var Token
386			*/
387	53		$token = $list->tokens[$list->idx];
388	53		$nextidx = $list->idx + 1;
389	53		while ($nextidx < $list->count && $list->tokens[$nextidx]->type == Token::TYPE_WHITESPACE) {
390	28		++$nextidx;
391			}
392
393	53		if ($this->options->has('DATABASE')) {
394	1		$this->entityOptions = OptionsArray::parse(
395	1		$parser,
396	1		$list,
397	1		static::$DB_OPTIONS
398			);
399	52		} elseif ($this->options->has('TABLE')
400	31		&& ($token->type == Token::TYPE_KEYWORD)
401	6		&& ($token->keyword == 'SELECT')
402			) {
403			/* CREATE TABLE ... SELECT */
404	2		$this->select = new SelectStatement($parser, $list);
405	50		} elseif ($this->options->has('TABLE')
406	29		&& ($token->type == Token::TYPE_KEYWORD) && ($token->keyword == 'AS')
407	1		&& ($list->tokens[$nextidx]->type == Token::TYPE_KEYWORD)
408	1		&& ($list->tokens[$nextidx]->value == 'SELECT')
409			) {
410			/* CREATE TABLE ... AS SELECT */
411	1		$list->idx = $nextidx;
412	1		$this->select = new SelectStatement($parser, $list);
413	49		} elseif ($this->options->has('TABLE')
414	28		&& $token->type == Token::TYPE_KEYWORD
415	3		&& $token->keyword == 'LIKE'
416			) {
417			/* CREATE TABLE `new_tbl` LIKE 'orig_tbl' */
418	3		$list->idx = $nextidx;
419	3		$this->like = Expression::parse(
420	3		$parser,
421	3		$list,
422			array(
423	3		'parseField' => 'table',
424			'breakOnAlias' => true,
425			)
426			);
427			// The 'LIKE' keyword was found, but no table_name was found next to it
428	3		if ($this->like == null) {
429	1		$parser->error(
430	1		'A table name was expected.',
431	1		$list->tokens[$list->idx]
432			);
433			}
434	47		} elseif ($this->options->has('TABLE')) {
435	26		$this->fields = CreateDefinition::parse($parser, $list);
436	26		if (empty($this->fields)) {
437	3		$parser->error(
438	3		'At least one column definition was expected.',
439	3		$list->tokens[$list->idx]
440			);
441			}
442	26		++$list->idx;
443
444	26		$this->entityOptions = OptionsArray::parse(
445	26		$parser,
446	26		$list,
447	26		static::$TABLE_OPTIONS
448			);
449
450			/**
451			* The field that is being filled (`partitionBy` or
452			* `subpartitionBy`).
453			*
454			* @var string
455			*/
456	26		$field = null;
457
458			/**
459			* The number of brackets. `false` means no bracket was found
460			* previously. At least one bracket is required to validate the
461			* expression.
462			*
463			* @var int\|bool
464			*/
465	26		$brackets = false;
466
467			/*
468			* Handles partitions.
469			*/
470	26		for (; $list->idx < $list->count; ++$list->idx) {
471			/**
472			* Token parsed at this moment.
473			*
474			* @var Token
475			*/
476	26		$token = $list->tokens[$list->idx];
477
478			// End of statement.
479	26		if ($token->type === Token::TYPE_DELIMITER) {
480	21		break;
481			}
482
483			// Skipping comments.
484	26		if ($token->type === Token::TYPE_COMMENT) {
485			continue;
486			}
487
488	26		if (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'PARTITION BY')) {
489	2		$field = 'partitionBy';
490	2		$brackets = false;
491	26		} elseif (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'SUBPARTITION BY')) {
492			$field = 'subpartitionBy';
493			$brackets = false;
494	26		} elseif (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'PARTITIONS')) {
495			$token = $list->getNextOfType(Token::TYPE_NUMBER);
496			--$list->idx; // `getNextOfType` also advances one position.
497			$this->partitionsNum = $token->value;
498	26		} elseif (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'SUBPARTITIONS')) {
499			$token = $list->getNextOfType(Token::TYPE_NUMBER);
500			--$list->idx; // `getNextOfType` also advances one position.
501			$this->subpartitionsNum = $token->value;
502			} elseif (!empty($field)) {
503			/*
504			* Handling the content of `PARTITION BY` and `SUBPARTITION BY`.
505			*/
506
507			// Counting brackets.
508	2		if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
509			// This is used instead of `++$brackets` because,
510			// initially, `$brackets` is `false` cannot be
511			// incremented.
512			$brackets = $brackets + 1;
513	2		} elseif (($token->type === Token::TYPE_OPERATOR) && ($token->value === ')')) {
514			--$brackets;
515			}
516
517			// Building the expression used for partitioning.
518	2		$this->field .= ($token->type === Token::TYPE_WHITESPACE) ? ' ' : $token->token;
			0 ignored issues – show Bug introduced 2017-10-10 10:55 UTC by Report Bug Copy Issue Report The property `field` does not seem to exist. Did you mean `fields`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
519
520			// Last bracket was read, the expression ended.
521			// Comparing with `0` and not `false`, because `false` means
522			// that no bracket was found and at least one must is
523			// required.
524			if ($brackets === 0) {
525			$this->field = trim($this->field);
			0 ignored issues – show Bug introduced 2017-10-10 10:55 UTC by Report Bug Copy Issue Report The property `field` does not seem to exist. Did you mean `fields`? An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
526			$field = null;
527			}
528	26		} elseif (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
529	3		if (!empty($this->partitionBy)) {
530			$this->partitions = ArrayObj::parse(
			0 ignored issues – show Documentation Bug introduced 2017-01-23 12:14 UTC by Report Bug Copy Issue Report It seems like `\PhpMyAdmin\SqlParser\Co...\PartitionDefinition'))` can also be of type `object<PhpMyAdmin\SqlParser\Components\ArrayObj>`. However, the property `$partitions` is declared as type `array<integer,object<Php...s\PartitionDefinition>>`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
531			$parser,
532			$list,
533			array(
534			'type' => 'PhpMyAdmin\\SqlParser\\Components\\PartitionDefinition',
535			)
536			);
537			}
538	3		break;
539			}
540			}
541	21		} elseif (($this->options->has('PROCEDURE'))
542	16		\|\| ($this->options->has('FUNCTION'))
543			) {
544	11		$this->parameters = ParameterDefinition::parse($parser, $list);
545	11		if ($this->options->has('FUNCTION')) {
546	6		$prev_token = $token;
547	6		$token = $list->getNextOfType(Token::TYPE_KEYWORD);
548	6		if (is_null($token) \|\| $token->keyword !== 'RETURNS') {
549	3		$parser->error(
550	3		'A "RETURNS" keyword was expected.',
551	3		is_null($token) ? $prev_token : $token
552			);
553			} else {
554	3		++$list->idx;
555	3		$this->return = DataType::parse(
556	3		$parser,
557	3		$list
558			);
559			}
560			}
561	11		++$list->idx;
562
563	11		$this->entityOptions = OptionsArray::parse(
564	11		$parser,
565	11		$list,
566	11		static::$FUNC_OPTIONS
567			);
568	11		++$list->idx;
569
570	11		for (; $list->idx < $list->count; ++$list->idx) {
571	9		$token = $list->tokens[$list->idx];
572	9		$this->body[] = $token;
573			}
574	10		} elseif ($this->options->has('VIEW')) {
575	5		$token = $list->getNext(); // Skipping whitespaces and comments.
576
577			// Parsing columns list.
578	5		if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
579	2		--$list->idx; // getNext() also goes forward one field.
580	2		$this->fields = ArrayObj::parse($parser, $list);
581	2		++$list->idx; // Skipping last token from the array.
582	2		$list->getNext();
583			}
584
585			// Parsing the `AS` keyword.
586	5	View Code Duplication	for (; $list->idx < $list->count; ++$list->idx) {
587	5		$token = $list->tokens[$list->idx];
588	5		if ($token->type === Token::TYPE_DELIMITER) {
589	5		break;
590			}
591	5		$this->body[] = $token;
592			}
593	5		} elseif ($this->options->has('TRIGGER')) {
594			// Parsing the time and the event.
595	1		$this->entityOptions = OptionsArray::parse(
596	1		$parser,
597	1		$list,
598	1		static::$TRIGGER_OPTIONS
599			);
600	1		++$list->idx;
601
602	1		$list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'ON');
603	1		++$list->idx; // Skipping `ON`.
604
605			// Parsing the name of the table.
606	1		$this->table = Expression::parse(
607	1		$parser,
608	1		$list,
609			array(
610	1		'parseField' => 'table',
611			'breakOnAlias' => true,
612			)
613			);
614	1		++$list->idx;
615
616	1		$list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'FOR EACH ROW');
617	1		++$list->idx; // Skipping `FOR EACH ROW`.
618
619	1		for (; $list->idx < $list->count; ++$list->idx) {
620	1		$token = $list->tokens[$list->idx];
621	1		$this->body[] = $token;
622			}
623			} else {
624	4	View Code Duplication	for (; $list->idx < $list->count; ++$list->idx) {
625	4		$token = $list->tokens[$list->idx];
626	4		if ($token->type === Token::TYPE_DELIMITER) {
627	4		break;
628			}
629	1		$this->body[] = $token;
630			}
631			}
632	51		}
633			}
634

phpmyadmin / sql-parser