{

/**

public static $databaseOptions = [

'CHARACTER SET' => [

1,

'var',

],

'CHARSET' => [

1,

'var',

],

'DEFAULT CHARACTER SET' => [

1,

'var',

],

'DEFAULT CHARSET' => [

1,

'var',

],

'UPGRADE' => [

1,

'var',

],

'COLLATE' => [

2,

'var',

],

'DEFAULT COLLATE' => [

2,

'var',

],

];

/**

public static $tableOptions = [

'ENGINE' => [

1,

'var=',

],

'ALGORITHM' => [

1,

'var=',

],

'AUTO_INCREMENT' => [

1,

'var=',

],

'AVG_ROW_LENGTH' => [

1,

'var',

],

'COALESCE PARTITION' => [

1,

'var',

],

'LOCK' => [

1,

'var=',

],

'MAX_ROWS' => [

1,

'var',

],

'ROW_FORMAT' => [

1,

'var',

],

'COMMENT' => [

1,

'var',

],

'ADD' => 1,

'ALTER' => 1,

'ANALYZE' => 1,

'CHANGE' => 1,

'CHARSET' => 1,

'CHECK' => 1,

'CONVERT' => 1,

'DEFAULT CHARSET' => 1,

'DISABLE' => 1,

'DISCARD' => 1,

'DROP' => 1,

'ENABLE' => 1,

'IMPORT' => 1,

'MODIFY' => 1,

'OPTIMIZE' => 1,

'ORDER' => 1,

'REBUILD' => 1,

'REMOVE' => 1,

'RENAME' => 1,

'REORGANIZE' => 1,

'REPAIR' => 1,

'UPGRADE' => 1,

'COLUMN' => 2,

'CONSTRAINT' => 2,

'DEFAULT' => 2,

'BY' => 2,

'FOREIGN' => 2,

'FULLTEXT' => 2,

'KEY' => 2,

'KEYS' => 2,

'PARTITION' => 2,

'PARTITION BY' => 2,

'PARTITIONING' => 2,

'PRIMARY KEY' => 2,

'SPATIAL' => 2,

'TABLESPACE' => 2,

'INDEX' => [

2,

'var',

],

'CHARACTER SET' => 3,

'TO' => [

3,

'var',

],

];

/**

public static $userOptions = [

'ATTRIBUTE' => [

1,

'var',

],

'COMMENT' => [

1,

'var',

],

'REQUIRE' => [

1,

'var',

],

'IDENTIFIED VIA' => [

2,

'var',

],

'IDENTIFIED WITH' => [

2,

'var',

],

'PASSWORD' => [

2,

'var',

],

'WITH' => [

2,

'var',

],

'BY' => [

4,

'expr',

],

'ACCOUNT' => 1,

'DEFAULT' => 1,

'LOCK' => 2,

'UNLOCK' => 2,

'IDENTIFIED' => 3,

];

/**

public static $viewOptions = ['AS' => 1];

/**

public static $eventOptions = [

'ON SCHEDULE' => 1,

'EVERY' => [

2,

'expr',

],

'AT' => [

2,

'expr',

],

'STARTS' => [

3,

'expr',

],

'ENDS' => [

4,

'expr',

],

'ON COMPLETION PRESERVE' => 5,

'ON COMPLETION NOT PRESERVE' => 5,

'RENAME' => 6,

'TO' => [

7,

'expr',

['parseField' => 'table'],

],

'ENABLE' => 8,

'DISABLE' => 8,

'DISABLE ON SLAVE' => 8,

'COMMENT' => [

9,

'var',

],

'DO' => 10,

];

/**

public $options;

/**

public $field;

/**

public $partitions;

/**

public $unknown = [];

/**

public function __construct(

$options = null,

$field = null,

$partitions = null,

$unknown = []

) {

$this->partitions = $partitions;

$this->options = $options;

$this->field = $field;

$this->unknown = $unknown;

}

/**

public static function parse(Parser $parser, TokensList $list, array $options = [])

{

$ret = new static();

/**

$brackets = 0;

/**

$state = 0;

/**

$partitionState = 0;

for (; $list->idx < $list->count; ++$list->idx) {

/**

$token = $list->tokens[$list->idx];

// End of statement.

if ($token->type === Token::TYPE_DELIMITER) {

break;

}

// Skipping comments.

if ($token->type === Token::TYPE_COMMENT) {

continue;

}

// Skipping whitespaces.

if ($token->type === Token::TYPE_WHITESPACE) {

if ($state === 2) {

// When parsing the unknown part, the whitespaces are

// included to not break anything.

$ret->unknown[] = $token;

continue;

}

}

if ($state === 0) {

$ret->options = OptionsArray::parse($parser, $list, $options);

// Not only when aliasing but also when parsing the body of an event, we just list the tokens of the

// body in the unknown tokens list, as they define their own statements.

if ($ret->options->has('AS') || $ret->options->has('DO')) {

for (; $list->idx < $list->count; ++$list->idx) {

if ($list->tokens[$list->idx]->type === Token::TYPE_DELIMITER) {

break;

}

$ret->unknown[] = $list->tokens[$list->idx];

}

break;

}

$state = 1;

if ($ret->options->has('PARTITION') || $token->value === 'PARTITION BY') {

$state = 3;

$list->getPrevious(); // in order to check whether it's partition or partition by.

}

} elseif ($state === 1) {

$ret->field = Expression::parse(

$parser,

$list,

[

'breakOnAlias' => true,

'parseField' => 'column',

]

);

if ($ret->field === null) {

// No field was read. We go back one token so the next

// iteration will parse the same token, but in state 2.

--$list->idx;

}

// If the operation is a RENAME COLUMN, now we have detected the field to rename, we need to parse

// again the options to get the new name of the column.

if ($ret->options->has('RENAME') && $ret->options->has('COLUMN')) {

$nextOptions = OptionsArray::parse($parser, $list, $options);

$ret->options->merge($nextOptions);

}

$state = 2;

} elseif ($state === 2) {

if (is_string($token->value) || is_numeric($token->value)) {

$arrayKey = $token->value;

} else {

$arrayKey = $token->token;

}

if ($token->type === Token::TYPE_OPERATOR) {

if ($token->value === '(') {

++$brackets;

} elseif ($token->value === ')') {

--$brackets;

} elseif (($token->value === ',') && ($brackets === 0)) {

break;

}

} elseif (! self::checkIfTokenQuotedSymbol($token)) {

// If the current token is "SET" or "ENUM", we want to avoid the token between their parenthesis in

// the unknown tokens.

if (in_array($token->value, ['SET', 'ENUM'], true)) {

$list->idx++; // Ignore the current token

$nextToken = $list->getNext();

if ($nextToken !== null && $nextToken->value === '(') {

$list->getNextOfTypeAndValue(Token::TYPE_OPERATOR, ')');

} elseif ($nextToken !== null && $nextToken->value === 'DEFAULT') {

// to avoid adding the `DEFAULT` token to the unknown tokens.

++$list->idx;

} else {

$parser->error(

'A new statement was found, but no delimiter between it and the previous one.',

$token

);

break;

}

} elseif (! empty(Parser::$statementParsers[$token->value])) {

// We have reached the end of ALTER operation and suddenly found

// a start to new statement, but have not found a delimiter between them

$parser->error(

'A new statement was found, but no delimiter between it and the previous one.',

$token

);

break;

} elseif (

(array_key_exists($arrayKey, self::$databaseOptions)

|| array_key_exists($arrayKey, self::$tableOptions))

&& ! self::checkIfColumnDefinitionKeyword($arrayKey)

) {

// This alter operation has finished, which means a comma

// was missing before start of new alter operation

$parser->error('Missing comma before start of a new alter operation.', $token);

break;

}

}

$ret->unknown[] = $token;

} elseif ($state === 3) {

if ($partitionState === 0) {

$list->idx++; // Ignore the current token

$nextToken = $list->getNext();

if (

($token->type === Token::TYPE_KEYWORD)

&& (($token->keyword === 'PARTITION BY')

|| ($token->keyword === 'PARTITION' && $nextToken && $nextToken->value !== '('))

) {

$partitionState = 1;

} elseif (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'PARTITION')) {

$partitionState = 2;

}

--$list->idx; // to decrease the idx by one, because the last getNext returned and increased it.

// reverting the effect of the getNext

$list->getPrevious();

$list->getPrevious();

++$list->idx; // to index the idx by one, because the last getPrevious returned and decreased it.

} elseif ($partitionState === 1) {

// Fetch the next token in a way the current index is reset to manage whitespaces in "field".

$currIdx = $list->idx;

++$list->idx;

$nextToken = $list->getNext();

$list->idx = $currIdx;

// Building the expression used for partitioning.

if (empty($ret->field)) {

$ret->field = '';

}

if (

$token->type === Token::TYPE_OPERATOR

&& $token->value === '('

&& $nextToken

&& $nextToken->keyword === 'PARTITION'

) {

$partitionState = 2;

--$list->idx; // Current idx is on "(". We need a step back for ArrayObj::parse incoming.

} else {

$ret->field .= $token->type === Token::TYPE_WHITESPACE ? ' ' : $token->token;

}

} elseif ($partitionState === 2) {

$ret->partitions = ArrayObj::parse(

$parser,

$list,

['type' => PartitionDefinition::class]

);

}

}

}

if ($ret->options->isEmpty()) {

$parser->error('Unrecognized alter operation.', $list->tokens[$list->idx]);

}

--$list->idx;

return $ret;

}

/**

public static function build($component): string

{

// Specific case of RENAME COLUMN that insert the field between 2 options.

$afterFieldsOptions = new OptionsArray();

if ($component->options->has('RENAME') && $component->options->has('COLUMN')) {

$afterFieldsOptions = clone $component->options;

$afterFieldsOptions->remove('RENAME');

$afterFieldsOptions->remove('COLUMN');

$component->options->remove('TO');

}

$ret = $component->options . ' ';

if (isset($component->field) && ($component->field !== '')) {

$ret .= $component->field . ' ';

}

$ret .= $afterFieldsOptions . TokensList::build($component->unknown);

if (isset($component->partitions)) {

$ret .= PartitionDefinition::build($component->partitions);

}

return trim($ret);

}

/**

private static function checkIfColumnDefinitionKeyword($tokenValue): bool

{

$commonOptions = [

'AUTO_INCREMENT',

'COMMENT',

'DEFAULT',

'CHARACTER SET',

'COLLATE',

'PRIMARY',

'UNIQUE',

'PRIMARY KEY',

'UNIQUE KEY',

];

// Since these options can be used for

// both table as well as a specific column in the table

return in_array($tokenValue, $commonOptions);

}

/**

private static function checkIfTokenQuotedSymbol($token): bool

{

return $token->type === Token::TYPE_SYMBOL && $token->flags === Token::FLAG_SYMBOL_BACKTICK;

}

public function __toString(): string

{

return static::build($this);

}