mirror of
https://gitlab.com/signalytic/client-external/streamline/streamline-emr.git
synced 2026-09-11 18:51:31 +00:00
updated streamline-setup v2
This commit is contained in:
@@ -0,0 +1,73 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser;
|
||||
|
||||
use Exception;
|
||||
use Stringable;
|
||||
|
||||
/**
|
||||
* Defines a component that is later extended to parse specialized components or keywords.
|
||||
*
|
||||
* There is a small difference between *Component and *Keyword classes: usually, *Component parsers can be reused in
|
||||
* multiple situations and *Keyword parsers count on the *Component classes to do their job.
|
||||
*
|
||||
* A component (of a statement) is a part of a statement that is common to multiple query types.
|
||||
*/
|
||||
abstract class Component implements Stringable
|
||||
{
|
||||
/**
|
||||
* Parses the tokens contained in the given list in the context of the given
|
||||
* parser.
|
||||
*
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return mixed
|
||||
*
|
||||
* @throws Exception not implemented yet.
|
||||
*/
|
||||
public static function parse(
|
||||
Parser $parser,
|
||||
TokensList $list,
|
||||
array $options = []
|
||||
) {
|
||||
// This method should be abstract, but it can't be both static and
|
||||
// abstract.
|
||||
throw new Exception(Translator::gettext('Not implemented yet.'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the string representation of a component of this type.
|
||||
*
|
||||
* In other words, this function represents the inverse function of
|
||||
* `static::parse`.
|
||||
*
|
||||
* @param mixed $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return mixed
|
||||
*
|
||||
* @throws Exception not implemented yet.
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
// This method should be abstract, but it can't be both static and
|
||||
// abstract.
|
||||
throw new Exception(Translator::gettext('Not implemented yet.'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the string representation of a component of this type.
|
||||
*
|
||||
* @see static::build
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function __toString()
|
||||
{
|
||||
return static::build($this);
|
||||
}
|
||||
}
|
||||
+617
@@ -0,0 +1,617 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function array_key_exists;
|
||||
use function in_array;
|
||||
use function is_int;
|
||||
use function is_string;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* Parses an alter operation.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class AlterOperation extends Component
|
||||
{
|
||||
/**
|
||||
* All database options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $DB_OPTIONS = [
|
||||
'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',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* All table options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $TABLE_OPTIONS = [
|
||||
'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,
|
||||
'var',
|
||||
],
|
||||
'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',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* All user options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $USER_OPTIONS = [
|
||||
'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,
|
||||
];
|
||||
|
||||
/**
|
||||
* All view options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $VIEW_OPTIONS = ['AS' => 1];
|
||||
|
||||
/**
|
||||
* All event options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $EVENT_OPTIONS = [
|
||||
'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', 'breakOnAlias' => true]],
|
||||
'ENABLE' => 8,
|
||||
'DISABLE' => 8,
|
||||
'DISABLE ON SLAVE' => 8,
|
||||
'COMMENT' => [
|
||||
9,
|
||||
'var',
|
||||
],
|
||||
'DO' => 10,
|
||||
];
|
||||
|
||||
/**
|
||||
* All routine (procedure or function) options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $ROUTINE_OPTIONS = [
|
||||
'COMMENT' => [
|
||||
1,
|
||||
'var',
|
||||
],
|
||||
'LANGUAGE SQL' => 2,
|
||||
'CONTAINS SQL' => 3,
|
||||
'NO SQL' => 3,
|
||||
'READS SQL DATA' => 3,
|
||||
'MODIFIES SQL DATA' => 3,
|
||||
'SQL SECURITY' => 4,
|
||||
'DEFINER' => 5,
|
||||
'INVOKER' => 5,
|
||||
];
|
||||
|
||||
/**
|
||||
* Options of this operation.
|
||||
*
|
||||
* @var OptionsArray
|
||||
*/
|
||||
public $options;
|
||||
|
||||
/**
|
||||
* The altered field.
|
||||
*
|
||||
* @var Expression|string|null
|
||||
*/
|
||||
public $field;
|
||||
|
||||
/**
|
||||
* The partitions.
|
||||
*
|
||||
* @var Component[]|ArrayObj|null
|
||||
*/
|
||||
public $partitions;
|
||||
|
||||
/**
|
||||
* Unparsed tokens.
|
||||
*
|
||||
* @var Token[]|string
|
||||
*/
|
||||
public $unknown = [];
|
||||
|
||||
/**
|
||||
* @param OptionsArray $options options of alter operation
|
||||
* @param Expression|string|null $field altered field
|
||||
* @param Component[]|ArrayObj|null $partitions partitions definition found in the operation
|
||||
* @param Token[] $unknown unparsed tokens found at the end of operation
|
||||
*/
|
||||
public function __construct(
|
||||
$options = null,
|
||||
$field = null,
|
||||
$partitions = null,
|
||||
$unknown = []
|
||||
) {
|
||||
$this->partitions = $partitions;
|
||||
$this->options = $options;
|
||||
$this->field = $field;
|
||||
$this->unknown = $unknown;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return AlterOperation
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* Counts brackets.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$brackets = 0;
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------------[ options ]---------------------> 1
|
||||
*
|
||||
* 1 ----------------------[ field ]----------------------> 2
|
||||
*
|
||||
* 1 -------------[ PARTITION / PARTITION BY ]------------> 3
|
||||
*
|
||||
* 2 -------------------------[ , ]-----------------------> 0
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
/**
|
||||
* partition state.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$partitionState = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$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_int($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) &&
|
||||
$token->type !== Token::TYPE_STRING &&
|
||||
$token->value !== 'CHECK'
|
||||
) {
|
||||
if (isset(Parser::$STATEMENT_PARSERS[$arrayKey]) && Parser::$STATEMENT_PARSERS[$arrayKey] !== '') {
|
||||
$list->idx++; // Ignore the current token
|
||||
$nextToken = $list->getNext();
|
||||
|
||||
if ($token->value === 'SET' && $nextToken !== null && $nextToken->value === '(') {
|
||||
// To avoid adding the tokens between the SET() parentheses to the unknown tokens
|
||||
$list->getNextOfTypeAndValue(Token::TYPE_OPERATOR, ')');
|
||||
} elseif ($token->value === 'SET' && $nextToken !== null && $nextToken->value === 'DEFAULT') {
|
||||
// to avoid adding the `DEFAULT` token to the unknown tokens.
|
||||
++$list->idx;
|
||||
} else {
|
||||
// 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::$DB_OPTIONS)
|
||||
|| array_key_exists($arrayKey, self::$TABLE_OPTIONS))
|
||||
&& ! 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;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param AlterOperation $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
// 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);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if token's value is one of the common keywords
|
||||
* between column and table alteration
|
||||
*
|
||||
* @param string $tokenValue Value of current token
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
private static function checkIfColumnDefinitionKeyword($tokenValue)
|
||||
{
|
||||
$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);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if token is symbol and quoted with backtick
|
||||
*
|
||||
* @param Token $token token to check
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
private static function checkIfTokenQuotedSymbol($token)
|
||||
{
|
||||
return $token->type === Token::TYPE_SYMBOL && $token->flags === Token::FLAG_SYMBOL_BACKTICK;
|
||||
}
|
||||
}
|
||||
+126
@@ -0,0 +1,126 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
use PhpMyAdmin\SqlParser\Translator;
|
||||
|
||||
use function count;
|
||||
use function sprintf;
|
||||
|
||||
/**
|
||||
* `VALUES` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class Array2d extends Component
|
||||
{
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return ArrayObj[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
/**
|
||||
* The number of values in each set.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$count = -1;
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ----------------------[ array ]----------------------> 1
|
||||
*
|
||||
* 1 ------------------------[ , ]------------------------> 0
|
||||
* 1 -----------------------[ else ]----------------------> (END)
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// No keyword is expected.
|
||||
if (($token->type === Token::TYPE_KEYWORD) && ($token->flags & Token::FLAG_KEYWORD_RESERVED)) {
|
||||
break;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->value !== '(') {
|
||||
break;
|
||||
}
|
||||
|
||||
$arr = ArrayObj::parse($parser, $list, $options);
|
||||
$arrCount = count($arr->values);
|
||||
if ($count === -1) {
|
||||
$count = $arrCount;
|
||||
} elseif ($arrCount !== $count) {
|
||||
$parser->error(
|
||||
sprintf(
|
||||
Translator::gettext('%1$d values were expected, but found %2$d.'),
|
||||
$count,
|
||||
$arrCount
|
||||
),
|
||||
$token
|
||||
);
|
||||
}
|
||||
|
||||
$ret[] = $arr;
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if ($token->value !== ',') {
|
||||
break;
|
||||
}
|
||||
|
||||
$state = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$parser->error('An opening bracket followed by a set of values was expected.', $list->tokens[$list->idx]);
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param ArrayObj[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
return ArrayObj::build($component);
|
||||
}
|
||||
}
|
||||
+185
@@ -0,0 +1,185 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
use function strlen;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* Parses an array.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class ArrayObj extends Component
|
||||
{
|
||||
/**
|
||||
* The array that contains the unprocessed value of each token.
|
||||
*
|
||||
* @var string[]
|
||||
*/
|
||||
public $raw = [];
|
||||
|
||||
/**
|
||||
* The array that contains the processed value of each token.
|
||||
*
|
||||
* @var string[]
|
||||
*/
|
||||
public $values = [];
|
||||
|
||||
/**
|
||||
* @param string[] $raw the unprocessed values
|
||||
* @param string[] $values the processed values
|
||||
*/
|
||||
public function __construct(array $raw = [], array $values = [])
|
||||
{
|
||||
$this->raw = $raw;
|
||||
$this->values = $values;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return ArrayObj|Component[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = empty($options['type']) ? new static() : [];
|
||||
|
||||
/**
|
||||
* The last raw expression.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$lastRaw = '';
|
||||
|
||||
/**
|
||||
* The last value.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$lastValue = '';
|
||||
|
||||
/**
|
||||
* Counts brackets.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$brackets = 0;
|
||||
|
||||
/**
|
||||
* Last separator (bracket or comma).
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
$isCommaLast = false;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
if ($brackets > 0) {
|
||||
$parser->error('A closing bracket was expected.', $token);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
$lastRaw .= $token->token;
|
||||
$lastValue = trim($lastValue) . ' ';
|
||||
continue;
|
||||
}
|
||||
|
||||
if (($brackets === 0) && (($token->type !== Token::TYPE_OPERATOR) || ($token->value !== '('))) {
|
||||
$parser->error('An opening bracket was expected.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->type === Token::TYPE_OPERATOR) {
|
||||
if ($token->value === '(') {
|
||||
if (++$brackets === 1) { // 1 is the base level.
|
||||
continue;
|
||||
}
|
||||
} elseif ($token->value === ')') {
|
||||
if (--$brackets === 0) { // Array ended.
|
||||
break;
|
||||
}
|
||||
} elseif ($token->value === ',') {
|
||||
if ($brackets === 1) {
|
||||
$isCommaLast = true;
|
||||
if (empty($options['type'])) {
|
||||
$ret->raw[] = trim($lastRaw);
|
||||
$ret->values[] = trim($lastValue);
|
||||
$lastRaw = $lastValue = '';
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (empty($options['type'])) {
|
||||
$lastRaw .= $token->token;
|
||||
$lastValue .= $token->value;
|
||||
} else {
|
||||
$ret[] = $options['type']::parse(
|
||||
$parser,
|
||||
$list,
|
||||
empty($options['typeOptions']) ? [] : $options['typeOptions']
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Handling last element.
|
||||
//
|
||||
// This is treated differently to treat the following cases:
|
||||
//
|
||||
// => []
|
||||
// [,] => ['', '']
|
||||
// [] => []
|
||||
// [a,] => ['a', '']
|
||||
// [a] => ['a']
|
||||
$lastRaw = trim($lastRaw);
|
||||
if (empty($options['type']) && ((strlen($lastRaw) > 0) || ($isCommaLast))) {
|
||||
$ret->raw[] = $lastRaw;
|
||||
$ret->values[] = trim($lastValue);
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param ArrayObj|ArrayObj[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return implode(', ', $component);
|
||||
}
|
||||
|
||||
if (! empty($component->raw)) {
|
||||
return '(' . implode(', ', $component->raw) . ')';
|
||||
}
|
||||
|
||||
return '(' . implode(', ', $component->values) . ')';
|
||||
}
|
||||
}
|
||||
+303
@@ -0,0 +1,303 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function count;
|
||||
|
||||
/**
|
||||
* Parses a reference to a CASE expression.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class CaseExpression extends Component
|
||||
{
|
||||
/**
|
||||
* The value to be compared.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $value;
|
||||
|
||||
/**
|
||||
* The conditions in WHEN clauses.
|
||||
*
|
||||
* @var Condition[][]
|
||||
*/
|
||||
public $conditions = [];
|
||||
|
||||
/**
|
||||
* The results matching with the WHEN clauses.
|
||||
*
|
||||
* @var Expression[]
|
||||
*/
|
||||
public $results = [];
|
||||
|
||||
/**
|
||||
* The values to be compared against.
|
||||
*
|
||||
* @var Expression[]
|
||||
*/
|
||||
public $compare_values = [];
|
||||
|
||||
/**
|
||||
* The result in ELSE section of expr.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $else_result;
|
||||
|
||||
/**
|
||||
* The alias of this CASE statement.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $alias;
|
||||
|
||||
/**
|
||||
* The sub-expression.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $expr = '';
|
||||
|
||||
public function __construct()
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return CaseExpression
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* State of parser.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
/**
|
||||
* Syntax type (type 0 or type 1).
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$type = 0;
|
||||
|
||||
++$list->idx; // Skip 'CASE'
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
switch ($token->keyword) {
|
||||
case 'WHEN':
|
||||
++$list->idx; // Skip 'WHEN'
|
||||
$newCondition = Condition::parse($parser, $list);
|
||||
$type = 1;
|
||||
$state = 1;
|
||||
$ret->conditions[] = $newCondition;
|
||||
break;
|
||||
case 'ELSE':
|
||||
++$list->idx; // Skip 'ELSE'
|
||||
$ret->else_result = Expression::parse($parser, $list);
|
||||
$state = 0; // last clause of CASE expression
|
||||
break;
|
||||
case 'END':
|
||||
$state = 3; // end of CASE expression
|
||||
++$list->idx;
|
||||
break 2;
|
||||
default:
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break 2;
|
||||
}
|
||||
} else {
|
||||
$ret->value = Expression::parse($parser, $list);
|
||||
$type = 0;
|
||||
$state = 1;
|
||||
}
|
||||
} elseif ($state === 1) {
|
||||
if ($type === 0) {
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
switch ($token->keyword) {
|
||||
case 'WHEN':
|
||||
++$list->idx; // Skip 'WHEN'
|
||||
$newValue = Expression::parse($parser, $list);
|
||||
$state = 2;
|
||||
$ret->compare_values[] = $newValue;
|
||||
break;
|
||||
case 'ELSE':
|
||||
++$list->idx; // Skip 'ELSE'
|
||||
$ret->else_result = Expression::parse($parser, $list);
|
||||
$state = 0; // last clause of CASE expression
|
||||
break;
|
||||
case 'END':
|
||||
$state = 3; // end of CASE expression
|
||||
++$list->idx;
|
||||
break 2;
|
||||
default:
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break 2;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'THEN') {
|
||||
++$list->idx; // Skip 'THEN'
|
||||
$newResult = Expression::parse($parser, $list);
|
||||
$state = 0;
|
||||
$ret->results[] = $newResult;
|
||||
} elseif ($token->type === Token::TYPE_KEYWORD) {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
}
|
||||
} elseif ($state === 2) {
|
||||
if ($type === 0) {
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'THEN') {
|
||||
++$list->idx; // Skip 'THEN'
|
||||
$newResult = Expression::parse($parser, $list);
|
||||
$ret->results[] = $newResult;
|
||||
$state = 1;
|
||||
} elseif ($token->type === Token::TYPE_KEYWORD) {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($state !== 3) {
|
||||
$parser->error('Unexpected end of CASE expression', $list->tokens[$list->idx - 1]);
|
||||
} else {
|
||||
// Parse for alias of CASE expression
|
||||
$asFound = false;
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Handle optional AS keyword before alias
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'AS') {
|
||||
if ($asFound || ! empty($ret->alias)) {
|
||||
$parser->error('Potential duplicate alias of CASE expression.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$asFound = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (
|
||||
$asFound
|
||||
&& $token->type === Token::TYPE_KEYWORD
|
||||
&& ($token->flags & Token::FLAG_KEYWORD_RESERVED || $token->flags & Token::FLAG_KEYWORD_FUNCTION)
|
||||
) {
|
||||
$parser->error('An alias expected after AS but got ' . $token->value, $token);
|
||||
$asFound = false;
|
||||
break;
|
||||
}
|
||||
|
||||
if (
|
||||
$asFound
|
||||
|| $token->type === Token::TYPE_STRING
|
||||
|| ($token->type === Token::TYPE_SYMBOL && ! $token->flags & Token::FLAG_SYMBOL_VARIABLE)
|
||||
|| $token->type === Token::TYPE_NONE
|
||||
) {
|
||||
// An alias is expected (the keyword `AS` was previously found).
|
||||
if (! empty($ret->alias)) {
|
||||
$parser->error('An alias was previously found.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$ret->alias = $token->value;
|
||||
$asFound = false;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if ($asFound) {
|
||||
$parser->error('An alias was expected after AS.', $list->tokens[$list->idx - 1]);
|
||||
}
|
||||
|
||||
$ret->expr = self::build($ret);
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param CaseExpression $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
$ret = 'CASE ';
|
||||
if (isset($component->value)) {
|
||||
// Syntax type 0
|
||||
$ret .= $component->value . ' ';
|
||||
$valuesCount = count($component->compare_values);
|
||||
$resultsCount = count($component->results);
|
||||
for ($i = 0; $i < $valuesCount && $i < $resultsCount; ++$i) {
|
||||
$ret .= 'WHEN ' . $component->compare_values[$i] . ' ';
|
||||
$ret .= 'THEN ' . $component->results[$i] . ' ';
|
||||
}
|
||||
} else {
|
||||
// Syntax type 1
|
||||
$valuesCount = count($component->conditions);
|
||||
$resultsCount = count($component->results);
|
||||
for ($i = 0; $i < $valuesCount && $i < $resultsCount; ++$i) {
|
||||
$ret .= 'WHEN ' . Condition::build($component->conditions[$i]) . ' ';
|
||||
$ret .= 'THEN ' . $component->results[$i] . ' ';
|
||||
}
|
||||
}
|
||||
|
||||
if (isset($component->else_result)) {
|
||||
$ret .= 'ELSE ' . $component->else_result . ' ';
|
||||
}
|
||||
|
||||
$ret .= 'END';
|
||||
|
||||
if ($component->alias) {
|
||||
$ret .= ' AS ' . Context::escape($component->alias);
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
}
|
||||
+243
@@ -0,0 +1,243 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function in_array;
|
||||
use function is_array;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `WHERE` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class Condition extends Component
|
||||
{
|
||||
/**
|
||||
* Logical operators that can be used to delimit expressions.
|
||||
*
|
||||
* @var string[]
|
||||
*/
|
||||
public static $DELIMITERS = [
|
||||
'&&',
|
||||
'||',
|
||||
'AND',
|
||||
'OR',
|
||||
'XOR',
|
||||
];
|
||||
|
||||
/**
|
||||
* List of allowed reserved keywords in conditions.
|
||||
*
|
||||
* @var array<string, int>
|
||||
*/
|
||||
public static $ALLOWED_KEYWORDS = [
|
||||
'ALL' => 1,
|
||||
'AND' => 1,
|
||||
'BETWEEN' => 1,
|
||||
'COLLATE' => 1,
|
||||
'EXISTS' => 1,
|
||||
'IF' => 1,
|
||||
'IN' => 1,
|
||||
'INTERVAL' => 1,
|
||||
'IS' => 1,
|
||||
'LIKE' => 1,
|
||||
'MATCH' => 1,
|
||||
'NOT IN' => 1,
|
||||
'NOT NULL' => 1,
|
||||
'NOT' => 1,
|
||||
'NULL' => 1,
|
||||
'OR' => 1,
|
||||
'REGEXP' => 1,
|
||||
'RLIKE' => 1,
|
||||
'SOUNDS' => 1,
|
||||
'XOR' => 1,
|
||||
];
|
||||
|
||||
/**
|
||||
* Identifiers recognized.
|
||||
*
|
||||
* @var array<int, mixed>
|
||||
*/
|
||||
public $identifiers = [];
|
||||
|
||||
/**
|
||||
* Whether this component is an operator.
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
public $isOperator = false;
|
||||
|
||||
/**
|
||||
* The condition.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $expr;
|
||||
|
||||
/**
|
||||
* @param string $expr the condition or the operator
|
||||
*/
|
||||
public function __construct($expr = null)
|
||||
{
|
||||
$this->expr = trim((string) $expr);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return Condition[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
$expr = new static();
|
||||
|
||||
/**
|
||||
* Counts brackets.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$brackets = 0;
|
||||
|
||||
/**
|
||||
* Whether there was a `BETWEEN` keyword before or not.
|
||||
*
|
||||
* It is required to keep track of them because their structure contains
|
||||
* the keyword `AND`, which is also an operator that delimits
|
||||
* expressions.
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
$betweenBefore = false;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if ($token->type === Token::TYPE_COMMENT) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Replacing all whitespaces (new lines, tabs, etc.) with a single
|
||||
// space character.
|
||||
if ($token->type === Token::TYPE_WHITESPACE) {
|
||||
$expr->expr .= ' ';
|
||||
continue;
|
||||
}
|
||||
|
||||
// Conditions are delimited by logical operators.
|
||||
if (
|
||||
($token->type === Token::TYPE_KEYWORD || $token->type === Token::TYPE_OPERATOR)
|
||||
&& in_array($token->value, static::$DELIMITERS, true)
|
||||
) {
|
||||
if ($betweenBefore && ($token->value === 'AND')) {
|
||||
// The syntax of keyword `BETWEEN` is hard-coded.
|
||||
$betweenBefore = false;
|
||||
} else {
|
||||
// The expression ended.
|
||||
$expr->expr = trim($expr->expr);
|
||||
if ($expr->expr !== '') {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
// Adding the operator.
|
||||
$expr = new static($token->value);
|
||||
$expr->isOperator = true;
|
||||
$ret[] = $expr;
|
||||
|
||||
// Preparing to parse another condition.
|
||||
$expr = new static();
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
($token->type === Token::TYPE_KEYWORD)
|
||||
&& ($token->flags & Token::FLAG_KEYWORD_RESERVED)
|
||||
&& ! ($token->flags & Token::FLAG_KEYWORD_FUNCTION)
|
||||
) {
|
||||
if ($token->value === 'BETWEEN') {
|
||||
$betweenBefore = true;
|
||||
}
|
||||
|
||||
if (($brackets === 0) && empty(static::$ALLOWED_KEYWORDS[$token->value])) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ($token->type === Token::TYPE_OPERATOR) {
|
||||
if ($token->value === '(') {
|
||||
++$brackets;
|
||||
} elseif ($token->value === ')') {
|
||||
if ($brackets === 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
--$brackets;
|
||||
}
|
||||
}
|
||||
|
||||
$expr->expr .= $token->token;
|
||||
if (
|
||||
($token->type !== Token::TYPE_NONE)
|
||||
&& (($token->type !== Token::TYPE_KEYWORD)
|
||||
|| ($token->flags & Token::FLAG_KEYWORD_RESERVED))
|
||||
&& ($token->type !== Token::TYPE_STRING)
|
||||
&& ($token->type !== Token::TYPE_SYMBOL || ($token->flags & Token::FLAG_SYMBOL_PARAMETER))
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (in_array($token->value, $expr->identifiers)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$expr->identifiers[] = $token->value;
|
||||
}
|
||||
|
||||
// Last iteration was not processed.
|
||||
$expr->expr = trim($expr->expr);
|
||||
if ($expr->expr !== '') {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Condition[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return implode(' ', $component);
|
||||
}
|
||||
|
||||
return $component->expr;
|
||||
}
|
||||
}
|
||||
+367
@@ -0,0 +1,367 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* Parses the create definition of a column or a key.
|
||||
*
|
||||
* Used for parsing `CREATE TABLE` statement.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class CreateDefinition extends Component
|
||||
{
|
||||
/**
|
||||
* All field options.
|
||||
*
|
||||
* @var array<string, bool|int|array<int, int|string|array<string, bool>>>
|
||||
* @psalm-var array<string, (bool|positive-int|array{
|
||||
* 0: positive-int,
|
||||
* 1: ('var'|'var='|'expr'|'expr='),
|
||||
* 2?: array<string, bool>
|
||||
* })>
|
||||
*/
|
||||
public static $FIELD_OPTIONS = [
|
||||
// Tells the `OptionsArray` to not sort the options.
|
||||
// See the note below.
|
||||
'_UNSORTED' => true,
|
||||
|
||||
'NOT NULL' => 1,
|
||||
'NULL' => 1,
|
||||
'DEFAULT' => [
|
||||
2,
|
||||
'expr',
|
||||
['breakOnAlias' => true],
|
||||
],
|
||||
/* Following are not according to grammar, but MySQL happily accepts
|
||||
* these at any location */
|
||||
'CHARSET' => [
|
||||
2,
|
||||
'var',
|
||||
],
|
||||
'COLLATE' => [
|
||||
3,
|
||||
'var',
|
||||
],
|
||||
'AUTO_INCREMENT' => 3,
|
||||
'KEY' => 4,
|
||||
'PRIMARY' => 4,
|
||||
'PRIMARY KEY' => 4,
|
||||
'UNIQUE' => 4,
|
||||
'UNIQUE KEY' => 4,
|
||||
'COMMENT' => [
|
||||
5,
|
||||
'var',
|
||||
],
|
||||
'COLUMN_FORMAT' => [
|
||||
6,
|
||||
'var',
|
||||
],
|
||||
'ON UPDATE' => [
|
||||
7,
|
||||
'expr',
|
||||
],
|
||||
|
||||
// Generated columns options.
|
||||
'GENERATED ALWAYS' => 8,
|
||||
'AS' => [
|
||||
9,
|
||||
'expr',
|
||||
['parenthesesDelimited' => true],
|
||||
],
|
||||
'VIRTUAL' => 10,
|
||||
'PERSISTENT' => 11,
|
||||
'STORED' => 11,
|
||||
'CHECK' => [
|
||||
12,
|
||||
'expr',
|
||||
['parenthesesDelimited' => true],
|
||||
],
|
||||
'INVISIBLE' => 13,
|
||||
'ENFORCED' => 14,
|
||||
'NOT' => 15,
|
||||
'COMPRESSED' => 16,
|
||||
'SRID' => [
|
||||
17,
|
||||
'var',
|
||||
],
|
||||
// Common entries.
|
||||
//
|
||||
// NOTE: Some of the common options are not in the same order which
|
||||
// causes troubles when checking if the options are in the right order.
|
||||
// I should find a way to define multiple sets of options and make the
|
||||
// parser select the right set.
|
||||
//
|
||||
// 'UNIQUE' => 4,
|
||||
// 'UNIQUE KEY' => 4,
|
||||
// 'COMMENT' => [5, 'var'],
|
||||
// 'NOT NULL' => 1,
|
||||
// 'NULL' => 1,
|
||||
// 'PRIMARY' => 4,
|
||||
// 'PRIMARY KEY' => 4,
|
||||
];
|
||||
|
||||
/**
|
||||
* The name of the new column.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $name;
|
||||
|
||||
/**
|
||||
* Whether this field is a constraint or not.
|
||||
*
|
||||
* @var bool|null
|
||||
*/
|
||||
public $isConstraint;
|
||||
|
||||
/**
|
||||
* The data type of thew new column.
|
||||
*
|
||||
* @var DataType|null
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* The key.
|
||||
*
|
||||
* @var Key|null
|
||||
*/
|
||||
public $key;
|
||||
|
||||
/**
|
||||
* The table that is referenced.
|
||||
*
|
||||
* @var Reference|null
|
||||
*/
|
||||
public $references;
|
||||
|
||||
/**
|
||||
* The options of this field.
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $options;
|
||||
|
||||
/**
|
||||
* @param string|null $name the name of the field
|
||||
* @param OptionsArray|null $options the options of this field
|
||||
* @param DataType|Key|null $type the data type of this field or the key
|
||||
* @param bool $isConstraint whether this field is a constraint or not
|
||||
* @param Reference|null $references references
|
||||
*/
|
||||
public function __construct(
|
||||
$name = null,
|
||||
$options = null,
|
||||
$type = null,
|
||||
$isConstraint = false,
|
||||
$references = null
|
||||
) {
|
||||
$this->name = $name;
|
||||
$this->options = $options;
|
||||
if ($type instanceof DataType) {
|
||||
$this->type = $type;
|
||||
} elseif ($type instanceof Key) {
|
||||
$this->key = $type;
|
||||
$this->isConstraint = $isConstraint;
|
||||
$this->references = $references;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return CreateDefinition[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
$expr = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 -----------------------[ ( ]------------------------> 1
|
||||
*
|
||||
* 1 --------------------[ CONSTRAINT ]------------------> 1
|
||||
* 1 -----------------------[ key ]----------------------> 2
|
||||
* 1 -------------[ constraint / column name ]-----------> 2
|
||||
*
|
||||
* 2 --------------------[ data type ]-------------------> 3
|
||||
*
|
||||
* 3 ---------------------[ options ]--------------------> 4
|
||||
*
|
||||
* 4 --------------------[ REFERENCES ]------------------> 4
|
||||
*
|
||||
* 5 ------------------------[ , ]-----------------------> 1
|
||||
* 5 ------------------------[ ) ]-----------------------> 6 (-1)
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if (($token->type !== Token::TYPE_OPERATOR) || ($token->value !== '(')) {
|
||||
$parser->error('An opening bracket was expected.', $token);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'CONSTRAINT') {
|
||||
$expr->isConstraint = true;
|
||||
} elseif (($token->type === Token::TYPE_KEYWORD) && ($token->flags & Token::FLAG_KEYWORD_KEY)) {
|
||||
$expr->key = Key::parse($parser, $list);
|
||||
$state = 4;
|
||||
} elseif ($token->type === Token::TYPE_SYMBOL || $token->type === Token::TYPE_NONE) {
|
||||
$expr->name = $token->value;
|
||||
if (! $expr->isConstraint) {
|
||||
$state = 2;
|
||||
}
|
||||
} elseif ($token->type === Token::TYPE_KEYWORD) {
|
||||
if ($token->flags & Token::FLAG_KEYWORD_RESERVED) {
|
||||
// Reserved keywords can't be used
|
||||
// as field names without backquotes
|
||||
$parser->error(
|
||||
'A symbol name was expected! '
|
||||
. 'A reserved keyword can not be used '
|
||||
. 'as a column name without backquotes.',
|
||||
$token
|
||||
);
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
// Non-reserved keywords are allowed without backquotes
|
||||
$expr->name = $token->value;
|
||||
$state = 2;
|
||||
} else {
|
||||
$parser->error('A symbol name was expected!', $token);
|
||||
|
||||
return $ret;
|
||||
}
|
||||
} elseif ($state === 2) {
|
||||
$expr->type = DataType::parse($parser, $list);
|
||||
$state = 3;
|
||||
} elseif ($state === 3) {
|
||||
$expr->options = OptionsArray::parse($parser, $list, static::$FIELD_OPTIONS);
|
||||
$state = 4;
|
||||
} elseif ($state === 4) {
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'REFERENCES') {
|
||||
++$list->idx; // Skipping keyword 'REFERENCES'.
|
||||
$expr->references = Reference::parse($parser, $list);
|
||||
} else {
|
||||
--$list->idx;
|
||||
}
|
||||
|
||||
$state = 5;
|
||||
} elseif ($state === 5) {
|
||||
if (! empty($expr->type) || ! empty($expr->key)) {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
$expr = new static();
|
||||
if ($token->value === ',') {
|
||||
$state = 1;
|
||||
} elseif ($token->value === ')') {
|
||||
$state = 6;
|
||||
++$list->idx;
|
||||
break;
|
||||
} else {
|
||||
$parser->error('A comma or a closing bracket was expected.', $token);
|
||||
$state = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Last iteration was not saved.
|
||||
if (! empty($expr->type) || ! empty($expr->key)) {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
if (($state !== 0) && ($state !== 6)) {
|
||||
$parser->error('A closing bracket was expected.', $list->tokens[$list->idx - 1]);
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param CreateDefinition|CreateDefinition[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return "(\n " . implode(",\n ", $component) . "\n)";
|
||||
}
|
||||
|
||||
$tmp = '';
|
||||
|
||||
if ($component->isConstraint) {
|
||||
$tmp .= 'CONSTRAINT ';
|
||||
}
|
||||
|
||||
if (isset($component->name) && ($component->name !== '')) {
|
||||
$tmp .= Context::escape($component->name) . ' ';
|
||||
}
|
||||
|
||||
if (! empty($component->type)) {
|
||||
$tmp .= DataType::build(
|
||||
$component->type,
|
||||
['lowercase' => true]
|
||||
) . ' ';
|
||||
}
|
||||
|
||||
if (! empty($component->key)) {
|
||||
$tmp .= $component->key . ' ';
|
||||
}
|
||||
|
||||
if (! empty($component->references)) {
|
||||
$tmp .= 'REFERENCES ' . $component->references . ' ';
|
||||
}
|
||||
|
||||
$tmp .= $component->options;
|
||||
|
||||
return trim($tmp);
|
||||
}
|
||||
}
|
||||
+175
@@ -0,0 +1,175 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function strtolower;
|
||||
use function strtoupper;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* Parses a data type.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class DataType extends Component
|
||||
{
|
||||
/**
|
||||
* All data type options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $DATA_TYPE_OPTIONS = [
|
||||
'BINARY' => 1,
|
||||
'CHARACTER SET' => [
|
||||
2,
|
||||
'var',
|
||||
],
|
||||
'CHARSET' => [
|
||||
2,
|
||||
'var',
|
||||
],
|
||||
'COLLATE' => [
|
||||
3,
|
||||
'var',
|
||||
],
|
||||
'UNSIGNED' => 4,
|
||||
'ZEROFILL' => 5,
|
||||
];
|
||||
|
||||
/**
|
||||
* The name of the data type.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $name;
|
||||
|
||||
/**
|
||||
* The parameters of this data type.
|
||||
*
|
||||
* Some data types have no parameters.
|
||||
* Numeric types might have parameters for the maximum number of digits,
|
||||
* precision, etc.
|
||||
* String types might have parameters for the maximum length stored.
|
||||
* `ENUM` and `SET` have parameters for possible values.
|
||||
*
|
||||
* For more information, check the MySQL manual.
|
||||
*
|
||||
* @var int[]|string[]
|
||||
*/
|
||||
public $parameters = [];
|
||||
|
||||
/**
|
||||
* The options of this data type.
|
||||
*
|
||||
* @var OptionsArray
|
||||
*/
|
||||
public $options;
|
||||
|
||||
/**
|
||||
* @param string $name the name of this data type
|
||||
* @param int[]|string[] $parameters the parameters (size or possible values)
|
||||
* @param OptionsArray $options the options of this data type
|
||||
*/
|
||||
public function __construct(
|
||||
$name = null,
|
||||
array $parameters = [],
|
||||
$options = null
|
||||
) {
|
||||
$this->name = $name;
|
||||
$this->parameters = $parameters;
|
||||
$this->options = $options;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return DataType|null
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 -------------------[ data type ]--------------------> 1
|
||||
*
|
||||
* 1 ----------------[ size and options ]----------------> 2
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$ret->name = strtoupper((string) $token->value);
|
||||
if (($token->type !== Token::TYPE_KEYWORD) || (! ($token->flags & Token::FLAG_KEYWORD_DATA_TYPE))) {
|
||||
$parser->error('Unrecognized data type.', $token);
|
||||
}
|
||||
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
|
||||
$parameters = ArrayObj::parse($parser, $list);
|
||||
++$list->idx;
|
||||
$ret->parameters = ($ret->name === 'ENUM') || ($ret->name === 'SET') ?
|
||||
$parameters->raw : $parameters->values;
|
||||
}
|
||||
|
||||
$ret->options = OptionsArray::parse($parser, $list, static::$DATA_TYPE_OPTIONS);
|
||||
++$list->idx;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (empty($ret->name)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param DataType $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
$name = empty($options['lowercase']) ?
|
||||
$component->name : strtolower($component->name);
|
||||
|
||||
$parameters = '';
|
||||
if (! empty($component->parameters)) {
|
||||
$parameters = '(' . implode(',', $component->parameters) . ')';
|
||||
}
|
||||
|
||||
return trim($name . $parameters . ' ' . $component->options);
|
||||
}
|
||||
}
|
||||
+493
@@ -0,0 +1,493 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Exceptions\ParserException;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
use function rtrim;
|
||||
use function strlen;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* Parses a reference to an expression (column, table or database name, function
|
||||
* call, mathematical expression, etc.).
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
#[\AllowDynamicProperties]
|
||||
class Expression extends Component
|
||||
{
|
||||
/**
|
||||
* List of allowed reserved keywords in expressions.
|
||||
*
|
||||
* @var array<string, int>
|
||||
*/
|
||||
private static $ALLOWED_KEYWORDS = [
|
||||
'AND' => 1,
|
||||
'AS' => 1,
|
||||
'BETWEEN' => 1,
|
||||
'CASE' => 1,
|
||||
'DUAL' => 1,
|
||||
'DIV' => 1,
|
||||
'IS' => 1,
|
||||
'MOD' => 1,
|
||||
'NOT' => 1,
|
||||
'NOT NULL' => 1,
|
||||
'NULL' => 1,
|
||||
'OR' => 1,
|
||||
'OVER' => 1,
|
||||
'REGEXP' => 1,
|
||||
'RLIKE' => 1,
|
||||
'XOR' => 1,
|
||||
];
|
||||
|
||||
/**
|
||||
* The name of this database.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $database;
|
||||
|
||||
/**
|
||||
* The name of this table.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $table;
|
||||
|
||||
/**
|
||||
* The name of the column.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $column;
|
||||
|
||||
/**
|
||||
* The sub-expression.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $expr = '';
|
||||
|
||||
/**
|
||||
* The alias of this expression.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $alias;
|
||||
|
||||
/**
|
||||
* The name of the function.
|
||||
*
|
||||
* @var mixed
|
||||
*/
|
||||
public $function;
|
||||
|
||||
/**
|
||||
* The type of subquery.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $subquery;
|
||||
|
||||
/**
|
||||
* Syntax:
|
||||
* new Expression('expr')
|
||||
* new Expression('expr', 'alias')
|
||||
* new Expression('database', 'table', 'column')
|
||||
* new Expression('database', 'table', 'column', 'alias')
|
||||
*
|
||||
* If the database, table or column name is not required, pass an empty
|
||||
* string.
|
||||
*
|
||||
* @param string|null $database The name of the database or the expression.
|
||||
* @param string|null $table The name of the table or the alias of the expression.
|
||||
* @param string|null $column the name of the column
|
||||
* @param string|null $alias the name of the alias
|
||||
*/
|
||||
public function __construct($database = null, $table = null, $column = null, $alias = null)
|
||||
{
|
||||
if (($column === null) && ($alias === null)) {
|
||||
$this->expr = $database; // case 1
|
||||
$this->alias = $table; // case 2
|
||||
} else {
|
||||
$this->database = $database; // case 3
|
||||
$this->table = $table; // case 3
|
||||
$this->column = $column; // case 3
|
||||
$this->alias = $alias; // case 4
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Possible options:.
|
||||
*
|
||||
* `field`
|
||||
*
|
||||
* First field to be filled.
|
||||
* If this is not specified, it takes the value of `parseField`.
|
||||
*
|
||||
* `parseField`
|
||||
*
|
||||
* Specifies the type of the field parsed. It may be `database`,
|
||||
* `table` or `column`. These expressions may not include
|
||||
* parentheses.
|
||||
*
|
||||
* `breakOnAlias`
|
||||
*
|
||||
* If not empty, breaks when the alias occurs (it is not included).
|
||||
*
|
||||
* `breakOnParentheses`
|
||||
*
|
||||
* If not empty, breaks when the first parentheses occurs.
|
||||
*
|
||||
* `parenthesesDelimited`
|
||||
*
|
||||
* If not empty, breaks after last parentheses occurred.
|
||||
*
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return Expression|null
|
||||
*
|
||||
* @throws ParserException
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* Whether current tokens make an expression or a table reference.
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
$isExpr = false;
|
||||
|
||||
/**
|
||||
* Whether a period was previously found.
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
$dot = false;
|
||||
|
||||
/**
|
||||
* Whether an alias is expected. Is 2 if `AS` keyword was found.
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
$alias = false;
|
||||
|
||||
/**
|
||||
* Counts brackets.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$brackets = 0;
|
||||
|
||||
/**
|
||||
* Keeps track of the last two previous tokens.
|
||||
*
|
||||
* @var Token[]
|
||||
*/
|
||||
$prev = [
|
||||
null,
|
||||
null,
|
||||
];
|
||||
|
||||
// When a field is parsed, no parentheses are expected.
|
||||
if (! empty($options['parseField'])) {
|
||||
$options['breakOnParentheses'] = true;
|
||||
$options['field'] = $options['parseField'];
|
||||
}
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
// If the token is a closing C comment from a MySQL command, it must be ignored.
|
||||
if ($isExpr && $token->token !== '*/') {
|
||||
$ret->expr .= $token->token;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if (($brackets > 0) && empty($ret->subquery) && ! empty(Parser::$STATEMENT_PARSERS[$token->keyword])) {
|
||||
// A `(` was previously found and this keyword is the
|
||||
// beginning of a statement, so this is a subquery.
|
||||
$ret->subquery = $token->keyword;
|
||||
} elseif (
|
||||
($token->flags & Token::FLAG_KEYWORD_FUNCTION)
|
||||
&& (empty($options['parseField'])
|
||||
&& ! $alias)
|
||||
) {
|
||||
$isExpr = true;
|
||||
} elseif (($token->flags & Token::FLAG_KEYWORD_RESERVED) && ($brackets === 0)) {
|
||||
if (empty(self::$ALLOWED_KEYWORDS[$token->keyword])) {
|
||||
// A reserved keyword that is not allowed in the
|
||||
// expression was found so the expression must have
|
||||
// ended and a new clause is starting.
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->keyword === 'AS') {
|
||||
if (! empty($options['breakOnAlias'])) {
|
||||
break;
|
||||
}
|
||||
|
||||
if ($alias) {
|
||||
$parser->error('An alias was expected.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$alias = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($token->keyword === 'CASE') {
|
||||
// For a use of CASE like
|
||||
// 'SELECT a = CASE .... END, b=1, `id`, ... FROM ...'
|
||||
$tempCaseExpr = CaseExpression::parse($parser, $list);
|
||||
$ret->expr .= CaseExpression::build($tempCaseExpr);
|
||||
$isExpr = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
$isExpr = true;
|
||||
} elseif (
|
||||
$brackets === 0 && strlen((string) $ret->expr) > 0 && ! $alias
|
||||
&& ($ret->table === null || $ret->table === '')
|
||||
) {
|
||||
/* End of expression */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
($token->type === Token::TYPE_NUMBER)
|
||||
|| ($token->type === Token::TYPE_BOOL)
|
||||
|| (($token->type === Token::TYPE_SYMBOL)
|
||||
&& ($token->flags & Token::FLAG_SYMBOL_VARIABLE))
|
||||
|| (($token->type === Token::TYPE_SYMBOL)
|
||||
&& ($token->flags & Token::FLAG_SYMBOL_PARAMETER))
|
||||
|| (($token->type === Token::TYPE_OPERATOR)
|
||||
&& ($token->value !== '.'))
|
||||
) {
|
||||
if (! empty($options['parseField'])) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Numbers, booleans and operators (except dot) are usually part
|
||||
// of expressions.
|
||||
$isExpr = true;
|
||||
}
|
||||
|
||||
if ($token->type === Token::TYPE_OPERATOR) {
|
||||
if (! empty($options['breakOnParentheses']) && (($token->value === '(') || ($token->value === ')'))) {
|
||||
// No brackets were expected.
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->value === '(') {
|
||||
++$brackets;
|
||||
if (
|
||||
empty($ret->function) && ($prev[1] !== null)
|
||||
&& (($prev[1]->type === Token::TYPE_NONE)
|
||||
|| ($prev[1]->type === Token::TYPE_SYMBOL)
|
||||
|| (($prev[1]->type === Token::TYPE_KEYWORD)
|
||||
&& ($prev[1]->flags & Token::FLAG_KEYWORD_FUNCTION)))
|
||||
) {
|
||||
$ret->function = $prev[1]->value;
|
||||
}
|
||||
} elseif ($token->value === ')') {
|
||||
if ($brackets === 0) {
|
||||
// Not our bracket
|
||||
break;
|
||||
}
|
||||
|
||||
--$brackets;
|
||||
if ($brackets === 0) {
|
||||
if (! empty($options['parenthesesDelimited'])) {
|
||||
// The current token is the last bracket, the next
|
||||
// one will be outside the expression.
|
||||
$ret->expr .= $token->token;
|
||||
++$list->idx;
|
||||
break;
|
||||
}
|
||||
} elseif ($brackets < 0) {
|
||||
// $parser->error('Unexpected closing bracket.', $token);
|
||||
// $brackets = 0;
|
||||
break;
|
||||
}
|
||||
} elseif ($token->value === ',') {
|
||||
// Expressions are comma-delimited.
|
||||
if ($brackets === 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Saving the previous tokens.
|
||||
$prev[0] = $prev[1];
|
||||
$prev[1] = $token;
|
||||
|
||||
if ($alias) {
|
||||
// An alias is expected (the keyword `AS` was previously found).
|
||||
if (! empty($ret->alias)) {
|
||||
$parser->error('An alias was previously found.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$ret->alias = $token->value;
|
||||
$alias = false;
|
||||
} elseif ($isExpr) {
|
||||
// Handling aliases.
|
||||
if (
|
||||
$brackets === 0
|
||||
&& ($prev[0] === null
|
||||
|| (($prev[0]->type !== Token::TYPE_OPERATOR || $prev[0]->token === ')')
|
||||
&& ($prev[0]->type !== Token::TYPE_KEYWORD
|
||||
|| ! ($prev[0]->flags & Token::FLAG_KEYWORD_RESERVED))))
|
||||
&& (($prev[1]->type === Token::TYPE_STRING)
|
||||
|| ($prev[1]->type === Token::TYPE_SYMBOL
|
||||
&& ! ($prev[1]->flags & Token::FLAG_SYMBOL_VARIABLE)
|
||||
&& ! ($prev[1]->flags & Token::FLAG_SYMBOL_PARAMETER))
|
||||
|| ($prev[1]->type === Token::TYPE_NONE
|
||||
&& $prev[1]->token !== 'OVER'))
|
||||
) {
|
||||
if (! empty($ret->alias)) {
|
||||
$parser->error('An alias was previously found.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$ret->alias = $prev[1]->value;
|
||||
} else {
|
||||
$currIdx = $list->idx;
|
||||
--$list->idx;
|
||||
$beforeToken = $list->getPrevious();
|
||||
$list->idx = $currIdx;
|
||||
// columns names tokens are of type NONE, or SYMBOL (`col`), and the columns options
|
||||
// would start with a token of type KEYWORD, in that case, we want to have a space
|
||||
// between the tokens.
|
||||
if (
|
||||
$ret->expr !== null &&
|
||||
$beforeToken &&
|
||||
($beforeToken->type === Token::TYPE_NONE ||
|
||||
$beforeToken->type === Token::TYPE_SYMBOL || $beforeToken->type === Token::TYPE_STRING) &&
|
||||
$token->type === Token::TYPE_KEYWORD
|
||||
) {
|
||||
$ret->expr = rtrim($ret->expr, ' ') . ' ';
|
||||
}
|
||||
|
||||
$ret->expr .= $token->token;
|
||||
}
|
||||
} elseif (! $isExpr) {
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '.')) {
|
||||
// Found a `.` which means we expect a column name and
|
||||
// the column name we parsed is actually the table name
|
||||
// and the table name is actually a database name.
|
||||
if (! empty($ret->database) || $dot) {
|
||||
$parser->error('Unexpected dot.', $token);
|
||||
}
|
||||
|
||||
$ret->database = $ret->table;
|
||||
$ret->table = $ret->column;
|
||||
$ret->column = null;
|
||||
$dot = true;
|
||||
$ret->expr .= $token->token;
|
||||
} else {
|
||||
$field = empty($options['field']) ? 'column' : $options['field'];
|
||||
if (empty($ret->$field)) {
|
||||
$ret->$field = $token->value;
|
||||
$ret->expr .= $token->token;
|
||||
$dot = false;
|
||||
} else {
|
||||
// No alias is expected.
|
||||
if (! empty($options['breakOnAlias'])) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (! empty($ret->alias)) {
|
||||
$parser->error('An alias was previously found.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$ret->alias = $token->value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($alias) {
|
||||
$parser->error('An alias was expected.', $list->tokens[$list->idx - 1]);
|
||||
}
|
||||
|
||||
// White-spaces might be added at the end.
|
||||
$ret->expr = trim((string) $ret->expr);
|
||||
|
||||
if ($ret->expr === '') {
|
||||
return null;
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Expression|Expression[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return implode(', ', $component);
|
||||
}
|
||||
|
||||
if ($component->expr !== '' && $component->expr !== null) {
|
||||
$ret = $component->expr;
|
||||
} else {
|
||||
$fields = [];
|
||||
if (isset($component->database) && ($component->database !== '')) {
|
||||
$fields[] = $component->database;
|
||||
}
|
||||
|
||||
if (isset($component->table) && ($component->table !== '')) {
|
||||
$fields[] = $component->table;
|
||||
}
|
||||
|
||||
if (isset($component->column) && ($component->column !== '')) {
|
||||
$fields[] = $component->column;
|
||||
}
|
||||
|
||||
$ret = implode('.', Context::escape($fields));
|
||||
}
|
||||
|
||||
if (! empty($component->alias)) {
|
||||
$ret .= ' AS ' . Context::escape($component->alias);
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
}
|
||||
+140
@@ -0,0 +1,140 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Exceptions\ParserException;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function count;
|
||||
use function implode;
|
||||
use function is_array;
|
||||
use function preg_match;
|
||||
use function strlen;
|
||||
use function substr;
|
||||
|
||||
/**
|
||||
* Parses a list of expressions delimited by a comma.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class ExpressionArray extends Component
|
||||
{
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return Expression[]
|
||||
*
|
||||
* @throws ParserException
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ----------------------[ array ]---------------------> 1
|
||||
*
|
||||
* 1 ------------------------[ , ]------------------------> 0
|
||||
* 1 -----------------------[ else ]----------------------> (END)
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (
|
||||
($token->type === Token::TYPE_KEYWORD)
|
||||
&& ($token->flags & Token::FLAG_KEYWORD_RESERVED)
|
||||
&& ((~$token->flags & Token::FLAG_KEYWORD_FUNCTION))
|
||||
&& ($token->value !== 'DUAL')
|
||||
&& ($token->value !== 'NULL')
|
||||
&& ($token->value !== 'CASE')
|
||||
&& ($token->value !== 'NOT')
|
||||
) {
|
||||
// No keyword is expected.
|
||||
break;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->value === 'CASE') {
|
||||
$expr = CaseExpression::parse($parser, $list, $options);
|
||||
} else {
|
||||
$expr = Expression::parse($parser, $list, $options);
|
||||
}
|
||||
|
||||
if ($expr === null) {
|
||||
break;
|
||||
}
|
||||
|
||||
$ret[] = $expr;
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if ($token->value !== ',') {
|
||||
break;
|
||||
}
|
||||
|
||||
$state = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$parser->error('An expression was expected.', $list->tokens[$list->idx]);
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
if (is_array($ret)) {
|
||||
$retIndex = count($ret) - 1;
|
||||
if (isset($ret[$retIndex])) {
|
||||
$expr = $ret[$retIndex]->expr;
|
||||
if (preg_match('/\s*--\s.*$/', $expr, $matches)) {
|
||||
$found = $matches[0];
|
||||
$ret[$retIndex]->expr = substr($expr, 0, strlen($expr) - strlen($found));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Expression[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
foreach ($component as $frag) {
|
||||
$ret[] = $frag::build($frag);
|
||||
}
|
||||
|
||||
return implode(', ', $ret);
|
||||
}
|
||||
}
|
||||
+117
@@ -0,0 +1,117 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function is_array;
|
||||
|
||||
/**
|
||||
* Parses a function call.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class FunctionCall extends Component
|
||||
{
|
||||
/**
|
||||
* The name of this function.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $name;
|
||||
|
||||
/**
|
||||
* The list of parameters.
|
||||
*
|
||||
* @var ArrayObj|null
|
||||
*/
|
||||
public $parameters;
|
||||
|
||||
/**
|
||||
* @param string|null $name the name of the function to be called
|
||||
* @param string[]|ArrayObj|null $parameters the parameters of this function
|
||||
*/
|
||||
public function __construct($name = null, $parameters = null)
|
||||
{
|
||||
$this->name = $name;
|
||||
if (is_array($parameters)) {
|
||||
$this->parameters = new ArrayObj($parameters);
|
||||
} elseif ($parameters instanceof ArrayObj) {
|
||||
$this->parameters = $parameters;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return FunctionCall
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ----------------------[ name ]-----------------------> 1
|
||||
*
|
||||
* 1 --------------------[ parameters ]-------------------> (END)
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
--$list->idx; // Let last token to previous one to avoid "This type of clause was previously parsed."
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->type === Token::TYPE_OPERATOR && $token->value === '(') {
|
||||
--$list->idx; // ArrayObj needs to start with `(`
|
||||
$state = 1;
|
||||
continue;// do not add this token to the name
|
||||
}
|
||||
|
||||
$ret->name .= $token->value;
|
||||
} elseif ($state === 1) {
|
||||
$ret->parameters = ArrayObj::parse($parser, $list);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FunctionCall $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
return $component->name . $component->parameters;
|
||||
}
|
||||
}
|
||||
+130
@@ -0,0 +1,130 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `GROUP BY` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class GroupKeyword extends Component
|
||||
{
|
||||
/** @var mixed */
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* The expression that is used for grouping.
|
||||
*
|
||||
* @var Expression
|
||||
*/
|
||||
public $expr;
|
||||
|
||||
/**
|
||||
* @param Expression $expr the expression that we are sorting by
|
||||
*/
|
||||
public function __construct($expr = null)
|
||||
{
|
||||
$this->expr = $expr;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return GroupKeyword[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
$expr = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 --------------------[ expression ]-------------------> 1
|
||||
*
|
||||
* 1 ------------------------[ , ]------------------------> 0
|
||||
* 1 -------------------[ ASC / DESC ]--------------------> 1
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$expr->expr = Expression::parse($parser, $list);
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if (
|
||||
($token->type === Token::TYPE_KEYWORD)
|
||||
&& (($token->keyword === 'ASC') || ($token->keyword === 'DESC'))
|
||||
) {
|
||||
$expr->type = $token->keyword;
|
||||
} elseif (($token->type === Token::TYPE_OPERATOR) && ($token->value === ',')) {
|
||||
if (! empty($expr->expr)) {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
$expr = new static();
|
||||
$state = 0;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Last iteration was not processed.
|
||||
if (! empty($expr->expr)) {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param GroupKeyword|GroupKeyword[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return implode(', ', $component);
|
||||
}
|
||||
|
||||
return trim((string) $component->expr);
|
||||
}
|
||||
}
|
||||
+207
@@ -0,0 +1,207 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
|
||||
/**
|
||||
* Parses an Index hint.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class IndexHint extends Component
|
||||
{
|
||||
/**
|
||||
* The type of hint (USE/FORCE/IGNORE)
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* What the hint is for (INDEX/KEY)
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $indexOrKey;
|
||||
|
||||
/**
|
||||
* The clause for which this hint is (JOIN/ORDER BY/GROUP BY)
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $for;
|
||||
|
||||
/**
|
||||
* List of indexes in this hint
|
||||
*
|
||||
* @var Expression[]
|
||||
*/
|
||||
public $indexes = [];
|
||||
|
||||
/**
|
||||
* @param string $type the type of hint (USE/FORCE/IGNORE)
|
||||
* @param string $indexOrKey What the hint is for (INDEX/KEY)
|
||||
* @param string $for the clause for which this hint is (JOIN/ORDER BY/GROUP BY)
|
||||
* @param Expression[] $indexes List of indexes in this hint
|
||||
*/
|
||||
public function __construct(
|
||||
?string $type = null,
|
||||
?string $indexOrKey = null,
|
||||
?string $for = null,
|
||||
array $indexes = []
|
||||
) {
|
||||
$this->type = $type;
|
||||
$this->indexOrKey = $indexOrKey;
|
||||
$this->for = $for;
|
||||
$this->indexes = $indexes;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return IndexHint|Component[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
$expr = new static();
|
||||
$expr->type = $options['type'] ?? null;
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
* 0 ----------------- [ USE/IGNORE/FORCE ]-----------------> 1
|
||||
* 1 -------------------- [ INDEX/KEY ] --------------------> 2
|
||||
* 2 ----------------------- [ FOR ] -----------------------> 3
|
||||
* 2 -------------------- [ expr_list ] --------------------> 0
|
||||
* 3 -------------- [ JOIN/GROUP BY/ORDER BY ] -------------> 4
|
||||
* 4 -------------------- [ expr_list ] --------------------> 0
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
// By design, the parser will parse first token after the keyword. So, the keyword
|
||||
// must be analyzed too, in order to determine the type of this index hint.
|
||||
if ($list->idx > 0) {
|
||||
--$list->idx;
|
||||
}
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
switch ($state) {
|
||||
case 0:
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if ($token->keyword !== 'USE' && $token->keyword !== 'IGNORE' && $token->keyword !== 'FORCE') {
|
||||
break 2;
|
||||
}
|
||||
|
||||
$expr->type = $token->keyword;
|
||||
$state = 1;
|
||||
}
|
||||
|
||||
break;
|
||||
case 1:
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if ($token->keyword === 'INDEX' || $token->keyword === 'KEY') {
|
||||
$expr->indexOrKey = $token->keyword;
|
||||
} else {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
}
|
||||
|
||||
$state = 2;
|
||||
} else {
|
||||
// we expect the token to be a keyword
|
||||
$parser->error('Unexpected token.', $token);
|
||||
}
|
||||
|
||||
break;
|
||||
case 2:
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'FOR') {
|
||||
$state = 3;
|
||||
} else {
|
||||
$expr->indexes = ExpressionArray::parse($parser, $list);
|
||||
$state = 0;
|
||||
$ret[] = $expr;
|
||||
$expr = new static();
|
||||
}
|
||||
|
||||
break;
|
||||
case 3:
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if (
|
||||
$token->keyword === 'JOIN'
|
||||
|| $token->keyword === 'GROUP BY'
|
||||
|| $token->keyword === 'ORDER BY'
|
||||
) {
|
||||
$expr->for = $token->keyword;
|
||||
} else {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
}
|
||||
|
||||
$state = 4;
|
||||
} else {
|
||||
// we expect the token to be a keyword
|
||||
$parser->error('Unexpected token.', $token);
|
||||
}
|
||||
|
||||
break;
|
||||
case 4:
|
||||
$expr->indexes = ExpressionArray::parse($parser, $list);
|
||||
$state = 0;
|
||||
$ret[] = $expr;
|
||||
$expr = new static();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param IndexHint|IndexHint[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return implode(' ', $component);
|
||||
}
|
||||
|
||||
$ret = $component->type . ' ' . $component->indexOrKey . ' ';
|
||||
if ($component->for !== null) {
|
||||
$ret .= 'FOR ' . $component->for . ' ';
|
||||
}
|
||||
|
||||
return $ret . ExpressionArray::build($component->indexes);
|
||||
}
|
||||
}
|
||||
+298
@@ -0,0 +1,298 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `INTO` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class IntoKeyword extends Component
|
||||
{
|
||||
/**
|
||||
* FIELDS/COLUMNS Options for `SELECT...INTO` statements.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $FIELDS_OPTIONS = [
|
||||
'TERMINATED BY' => [
|
||||
1,
|
||||
'expr',
|
||||
],
|
||||
'OPTIONALLY' => 2,
|
||||
'ENCLOSED BY' => [
|
||||
3,
|
||||
'expr',
|
||||
],
|
||||
'ESCAPED BY' => [
|
||||
4,
|
||||
'expr',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* LINES Options for `SELECT...INTO` statements.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $LINES_OPTIONS = [
|
||||
'STARTING BY' => [
|
||||
1,
|
||||
'expr',
|
||||
],
|
||||
'TERMINATED BY' => [
|
||||
2,
|
||||
'expr',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* Type of target (OUTFILE or SYMBOL).
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* The destination, which can be a table or a file.
|
||||
*
|
||||
* @var string|Expression|null
|
||||
*/
|
||||
public $dest;
|
||||
|
||||
/**
|
||||
* The name of the columns.
|
||||
*
|
||||
* @var string[]|null
|
||||
*/
|
||||
public $columns;
|
||||
|
||||
/**
|
||||
* The values to be selected into (SELECT .. INTO @var1).
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $values;
|
||||
|
||||
/**
|
||||
* Options for FIELDS/COLUMNS keyword.
|
||||
*
|
||||
* @see static::$FIELDS_OPTIONS
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $fields_options;
|
||||
|
||||
/**
|
||||
* Whether to use `FIELDS` or `COLUMNS` while building.
|
||||
*
|
||||
* @var bool|null
|
||||
*/
|
||||
public $fields_keyword;
|
||||
|
||||
/**
|
||||
* Options for OPTIONS keyword.
|
||||
*
|
||||
* @see static::$LINES_OPTIONS
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $lines_options;
|
||||
|
||||
/**
|
||||
* @param string|null $type type of destination (may be OUTFILE)
|
||||
* @param string|Expression|null $dest actual destination
|
||||
* @param string[]|null $columns column list of destination
|
||||
* @param Expression[]|null $values selected fields
|
||||
* @param OptionsArray|null $fieldsOptions options for FIELDS/COLUMNS keyword
|
||||
* @param bool|null $fieldsKeyword options for OPTIONS keyword
|
||||
*/
|
||||
public function __construct(
|
||||
$type = null,
|
||||
$dest = null,
|
||||
$columns = null,
|
||||
$values = null,
|
||||
$fieldsOptions = null,
|
||||
$fieldsKeyword = null
|
||||
) {
|
||||
$this->type = $type;
|
||||
$this->dest = $dest;
|
||||
$this->columns = $columns;
|
||||
$this->values = $values;
|
||||
$this->fields_options = $fieldsOptions;
|
||||
$this->fields_keyword = $fieldsKeyword;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return IntoKeyword
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 -----------------------[ name ]----------------------> 1
|
||||
* 0 ---------------------[ OUTFILE ]---------------------> 2
|
||||
*
|
||||
* 1 ------------------------[ ( ]------------------------> (END)
|
||||
*
|
||||
* 2 ---------------------[ filename ]--------------------> 1
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (($token->type === Token::TYPE_KEYWORD) && ($token->flags & Token::FLAG_KEYWORD_RESERVED)) {
|
||||
if (($state === 0) && ($token->keyword === 'OUTFILE')) {
|
||||
$ret->type = 'OUTFILE';
|
||||
$state = 2;
|
||||
continue;
|
||||
}
|
||||
|
||||
// No other keyword is expected except for $state = 4, which expects `LINES`
|
||||
if ($state !== 4) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if (
|
||||
(isset($options['fromInsert'])
|
||||
&& $options['fromInsert'])
|
||||
|| (isset($options['fromReplace'])
|
||||
&& $options['fromReplace'])
|
||||
) {
|
||||
$ret->dest = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
[
|
||||
'parseField' => 'table',
|
||||
'breakOnAlias' => true,
|
||||
]
|
||||
);
|
||||
} else {
|
||||
$ret->values = ExpressionArray::parse($parser, $list);
|
||||
}
|
||||
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
|
||||
$ret->columns = ArrayObj::parse($parser, $list)->values;
|
||||
++$list->idx;
|
||||
}
|
||||
|
||||
break;
|
||||
} elseif ($state === 2) {
|
||||
$ret->dest = $token->value;
|
||||
|
||||
$state = 3;
|
||||
} elseif ($state === 3) {
|
||||
$ret->parseFileOptions($parser, $list, $token->keyword);
|
||||
$state = 4;
|
||||
} elseif ($state === 4) {
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword !== 'LINES') {
|
||||
break;
|
||||
}
|
||||
|
||||
$ret->parseFileOptions($parser, $list, $token->keyword);
|
||||
$state = 5;
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser The parser
|
||||
* @param TokensList $list A token list
|
||||
* @param string $keyword The keyword
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function parseFileOptions(Parser $parser, TokensList $list, $keyword = 'FIELDS')
|
||||
{
|
||||
++$list->idx;
|
||||
|
||||
if ($keyword === 'FIELDS' || $keyword === 'COLUMNS') {
|
||||
// parse field options
|
||||
$this->fields_options = OptionsArray::parse($parser, $list, static::$FIELDS_OPTIONS);
|
||||
|
||||
$this->fields_keyword = ($keyword === 'FIELDS');
|
||||
} else {
|
||||
// parse line options
|
||||
$this->lines_options = OptionsArray::parse($parser, $list, static::$LINES_OPTIONS);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param IntoKeyword $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if ($component->dest instanceof Expression) {
|
||||
$columns = ! empty($component->columns) ? '(`' . implode('`, `', $component->columns) . '`)' : '';
|
||||
|
||||
return $component->dest . $columns;
|
||||
}
|
||||
|
||||
if (isset($component->values)) {
|
||||
return ExpressionArray::build($component->values);
|
||||
}
|
||||
|
||||
$ret = 'OUTFILE "' . $component->dest . '"';
|
||||
|
||||
$fieldsOptionsString = OptionsArray::build($component->fields_options);
|
||||
if (trim($fieldsOptionsString) !== '') {
|
||||
$ret .= $component->fields_keyword ? ' FIELDS' : ' COLUMNS';
|
||||
$ret .= ' ' . $fieldsOptionsString;
|
||||
}
|
||||
|
||||
$linesOptionsString = OptionsArray::build($component->lines_options, ['expr' => true]);
|
||||
if (trim($linesOptionsString) !== '') {
|
||||
$ret .= ' LINES ' . $linesOptionsString;
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
}
|
||||
+221
@@ -0,0 +1,221 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function array_search;
|
||||
use function implode;
|
||||
|
||||
/**
|
||||
* `JOIN` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class JoinKeyword extends Component
|
||||
{
|
||||
/**
|
||||
* Types of join.
|
||||
*
|
||||
* @var array<string, string>
|
||||
*/
|
||||
public static $JOINS = [
|
||||
'CROSS JOIN' => 'CROSS',
|
||||
'FULL JOIN' => 'FULL',
|
||||
'FULL OUTER JOIN' => 'FULL',
|
||||
'INNER JOIN' => 'INNER',
|
||||
'JOIN' => 'JOIN',
|
||||
'LEFT JOIN' => 'LEFT',
|
||||
'LEFT OUTER JOIN' => 'LEFT',
|
||||
'RIGHT JOIN' => 'RIGHT',
|
||||
'RIGHT OUTER JOIN' => 'RIGHT',
|
||||
'NATURAL JOIN' => 'NATURAL',
|
||||
'NATURAL LEFT JOIN' => 'NATURAL LEFT',
|
||||
'NATURAL RIGHT JOIN' => 'NATURAL RIGHT',
|
||||
'NATURAL LEFT OUTER JOIN' => 'NATURAL LEFT OUTER',
|
||||
'NATURAL RIGHT OUTER JOIN' => 'NATURAL RIGHT OUTER',
|
||||
'STRAIGHT_JOIN' => 'STRAIGHT',
|
||||
];
|
||||
|
||||
/**
|
||||
* Type of this join.
|
||||
*
|
||||
* @see static::$JOINS
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* Join expression.
|
||||
*
|
||||
* @var Expression
|
||||
*/
|
||||
public $expr;
|
||||
|
||||
/**
|
||||
* Join conditions.
|
||||
*
|
||||
* @var Condition[]
|
||||
*/
|
||||
public $on;
|
||||
|
||||
/**
|
||||
* Columns in Using clause.
|
||||
*
|
||||
* @var ArrayObj
|
||||
*/
|
||||
public $using;
|
||||
|
||||
/**
|
||||
* @see JoinKeyword::$JOINS
|
||||
*
|
||||
* @param string $type Join type
|
||||
* @param Expression $expr join expression
|
||||
* @param Condition[] $on join conditions
|
||||
* @param ArrayObj $using columns joined
|
||||
*/
|
||||
public function __construct($type = null, $expr = null, $on = null, $using = null)
|
||||
{
|
||||
$this->type = $type;
|
||||
$this->expr = $expr;
|
||||
$this->on = $on;
|
||||
$this->using = $using;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return JoinKeyword[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
$expr = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 -----------------------[ JOIN ]----------------------> 1
|
||||
*
|
||||
* 1 -----------------------[ expr ]----------------------> 2
|
||||
*
|
||||
* 2 ------------------------[ ON ]-----------------------> 3
|
||||
* 2 -----------------------[ USING ]---------------------> 4
|
||||
*
|
||||
* 3 --------------------[ conditions ]-------------------> 0
|
||||
*
|
||||
* 4 ----------------------[ columns ]--------------------> 0
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
// By design, the parser will parse first token after the keyword.
|
||||
// In this case, the keyword must be analyzed too, in order to determine
|
||||
// the type of this join.
|
||||
if ($list->idx > 0) {
|
||||
--$list->idx;
|
||||
}
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if (($token->type !== Token::TYPE_KEYWORD) || empty(static::$JOINS[$token->keyword])) {
|
||||
break;
|
||||
}
|
||||
|
||||
$expr->type = static::$JOINS[$token->keyword];
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
$expr->expr = Expression::parse($parser, $list, ['field' => 'table']);
|
||||
$state = 2;
|
||||
} elseif ($state === 2) {
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
switch ($token->keyword) {
|
||||
case 'ON':
|
||||
$state = 3;
|
||||
break;
|
||||
case 'USING':
|
||||
$state = 4;
|
||||
break;
|
||||
default:
|
||||
if (empty(static::$JOINS[$token->keyword])) {
|
||||
/* Next clause is starting */
|
||||
break 2;
|
||||
}
|
||||
|
||||
$ret[] = $expr;
|
||||
$expr = new static();
|
||||
$expr->type = static::$JOINS[$token->keyword];
|
||||
$state = 1;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
} elseif ($state === 3) {
|
||||
$expr->on = Condition::parse($parser, $list);
|
||||
$ret[] = $expr;
|
||||
$expr = new static();
|
||||
$state = 0;
|
||||
} elseif ($state === 4) {
|
||||
$expr->using = ArrayObj::parse($parser, $list);
|
||||
$ret[] = $expr;
|
||||
$expr = new static();
|
||||
$state = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (! empty($expr->type)) {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param JoinKeyword[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
foreach ($component as $c) {
|
||||
$ret[] = array_search($c->type, static::$JOINS) . ' ' . $c->expr
|
||||
. (! empty($c->on)
|
||||
? ' ON ' . Condition::build($c->on) : '')
|
||||
. (! empty($c->using)
|
||||
? ' USING ' . ArrayObj::build($c->using) : '');
|
||||
}
|
||||
|
||||
return implode(' ', $ret);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,307 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* Parses the definition of a key.
|
||||
*
|
||||
* Used for parsing `CREATE TABLE` statement.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class Key extends Component
|
||||
{
|
||||
/**
|
||||
* All key options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $KEY_OPTIONS = [
|
||||
'KEY_BLOCK_SIZE' => [
|
||||
1,
|
||||
'var=',
|
||||
],
|
||||
'USING' => [
|
||||
2,
|
||||
'var',
|
||||
],
|
||||
'WITH PARSER' => [
|
||||
3,
|
||||
'var',
|
||||
],
|
||||
'COMMENT' => [
|
||||
4,
|
||||
'var',
|
||||
],
|
||||
// MariaDB options
|
||||
'CLUSTERING' => [
|
||||
4,
|
||||
'var=',
|
||||
],
|
||||
'ENGINE_ATTRIBUTE' => [
|
||||
5,
|
||||
'var=',
|
||||
],
|
||||
'SECONDARY_ENGINE_ATTRIBUTE' => [
|
||||
5,
|
||||
'var=',
|
||||
],
|
||||
// MariaDB & MySQL options
|
||||
'VISIBLE' => 6,
|
||||
'INVISIBLE' => 6,
|
||||
// MariaDB options
|
||||
'IGNORED' => 10,
|
||||
'NOT IGNORED' => 10,
|
||||
];
|
||||
|
||||
/**
|
||||
* The name of this key.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $name;
|
||||
|
||||
/**
|
||||
* The key columns
|
||||
*
|
||||
* @var array<int, array<string, int|string>>
|
||||
* @phpstan-var array{name?: string, length?: int, order?: string}[]
|
||||
*/
|
||||
public $columns;
|
||||
|
||||
/**
|
||||
* The type of this key.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* The expression if the Key is not using column names
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $expr = null;
|
||||
|
||||
/**
|
||||
* The options of this key or null if none where found.
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $options;
|
||||
|
||||
/**
|
||||
* @param string $name the name of the key
|
||||
* @param array<int, array<string, int|string>> $columns the columns covered by this key
|
||||
* @param string $type the type of this key
|
||||
* @param OptionsArray $options the options of this key
|
||||
* @phpstan-param array{name?: string, length?: int, order?: string}[] $columns
|
||||
*/
|
||||
public function __construct(
|
||||
$name = null,
|
||||
array $columns = [],
|
||||
$type = null,
|
||||
$options = null
|
||||
) {
|
||||
$this->name = $name;
|
||||
$this->columns = $columns;
|
||||
$this->type = $type;
|
||||
$this->options = $options;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return Key
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* Last parsed column.
|
||||
*
|
||||
* @var array<string,mixed>
|
||||
*/
|
||||
$lastColumn = [];
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------------[ type ]---------------------------> 1
|
||||
*
|
||||
* 1 ---------------------[ name ]---------------------------> 1
|
||||
* 1 ---------------------[ columns ]------------------------> 2
|
||||
* 1 ---------------------[ expression ]---------------------> 5
|
||||
*
|
||||
* 2 ---------------------[ column length ]------------------> 3
|
||||
* 3 ---------------------[ column length ]------------------> 2
|
||||
* 2 ---------------------[ options ]------------------------> 4
|
||||
* 5 ---------------------[ expression ]---------------------> 4
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$ret->type = $token->value;
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
|
||||
$positionBeforeSearch = $list->idx;
|
||||
$list->idx++;// Ignore the current token "(" or the search condition will always be true
|
||||
$nextToken = $list->getNext();
|
||||
$list->idx = $positionBeforeSearch;// Restore the position
|
||||
|
||||
if ($nextToken !== null && $nextToken->value === '(') {
|
||||
// Switch to expression mode
|
||||
$state = 5;
|
||||
} else {
|
||||
$state = 2;
|
||||
}
|
||||
} else {
|
||||
$ret->name = $token->value;
|
||||
}
|
||||
} elseif ($state === 2) {
|
||||
if ($token->type === Token::TYPE_OPERATOR) {
|
||||
if ($token->value === '(') {
|
||||
$state = 3;
|
||||
} elseif (($token->value === ',') || ($token->value === ')')) {
|
||||
$state = $token->value === ',' ? 2 : 4;
|
||||
if (! empty($lastColumn)) {
|
||||
$ret->columns[] = $lastColumn;
|
||||
$lastColumn = [];
|
||||
}
|
||||
}
|
||||
} elseif (
|
||||
(
|
||||
$token->type === Token::TYPE_KEYWORD
|
||||
)
|
||||
&&
|
||||
(
|
||||
($token->keyword === 'ASC') || ($token->keyword === 'DESC')
|
||||
)
|
||||
) {
|
||||
$lastColumn['order'] = $token->keyword;
|
||||
} else {
|
||||
$lastColumn['name'] = $token->value;
|
||||
}
|
||||
} elseif ($state === 3) {
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === ')')) {
|
||||
$state = 2;
|
||||
} else {
|
||||
$lastColumn['length'] = $token->value;
|
||||
}
|
||||
} elseif ($state === 4) {
|
||||
$ret->options = OptionsArray::parse($parser, $list, static::$KEY_OPTIONS);
|
||||
++$list->idx;
|
||||
break;
|
||||
} elseif ($state === 5) {
|
||||
if ($token->type === Token::TYPE_OPERATOR) {
|
||||
// This got back to here and we reached the end of the expression
|
||||
if ($token->value === ')') {
|
||||
$state = 4;// go back to state 4 to fetch options
|
||||
continue;
|
||||
}
|
||||
|
||||
// The expression is not finished, adding a separator for the next expression
|
||||
if ($token->value === ',') {
|
||||
$ret->expr .= ', ';
|
||||
continue;
|
||||
}
|
||||
|
||||
// Start of the expression
|
||||
if ($token->value === '(') {
|
||||
// This is the first expression, set to empty
|
||||
if ($ret->expr === null) {
|
||||
$ret->expr = '';
|
||||
}
|
||||
|
||||
$ret->expr .= Expression::parse($parser, $list, ['parenthesesDelimited' => true]);
|
||||
continue;
|
||||
}
|
||||
// Another unexpected operator was found
|
||||
}
|
||||
|
||||
// Something else than an operator was found
|
||||
$parser->error('Unexpected token.', $token);
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Key $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
$ret = $component->type . ' ';
|
||||
if (! empty($component->name)) {
|
||||
$ret .= Context::escape($component->name) . ' ';
|
||||
}
|
||||
|
||||
if ($component->expr !== null) {
|
||||
return $ret . '(' . $component->expr . ') ' . $component->options;
|
||||
}
|
||||
|
||||
$columns = [];
|
||||
foreach ($component->columns as $column) {
|
||||
$tmp = '';
|
||||
if (isset($column['name'])) {
|
||||
$tmp .= Context::escape($column['name']);
|
||||
}
|
||||
|
||||
if (isset($column['length'])) {
|
||||
$tmp .= '(' . $column['length'] . ')';
|
||||
}
|
||||
|
||||
if (isset($column['order'])) {
|
||||
$tmp .= ' ' . $column['order'];
|
||||
}
|
||||
|
||||
$columns[] = $tmp;
|
||||
}
|
||||
|
||||
$ret .= '(' . implode(',', $columns) . ') ' . $component->options;
|
||||
|
||||
return trim($ret);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
/**
|
||||
* `LIMIT` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class Limit extends Component
|
||||
{
|
||||
/**
|
||||
* The number of rows skipped.
|
||||
*
|
||||
* @var int|string
|
||||
*/
|
||||
public $offset;
|
||||
|
||||
/**
|
||||
* The number of rows to be returned.
|
||||
*
|
||||
* @var int|string
|
||||
*/
|
||||
public $rowCount;
|
||||
|
||||
/**
|
||||
* @param int|string $rowCount the row count
|
||||
* @param int|string $offset the offset
|
||||
*/
|
||||
public function __construct($rowCount = 0, $offset = 0)
|
||||
{
|
||||
$this->rowCount = $rowCount;
|
||||
$this->offset = $offset;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return Limit
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
$offset = false;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (($token->type === Token::TYPE_KEYWORD) && ($token->flags & Token::FLAG_KEYWORD_RESERVED)) {
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'OFFSET') {
|
||||
if ($offset) {
|
||||
$parser->error('An offset was expected.', $token);
|
||||
}
|
||||
|
||||
$offset = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === ',')) {
|
||||
$ret->offset = $ret->rowCount;
|
||||
$ret->rowCount = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Skip if not a number or a bind parameter (?)
|
||||
if (
|
||||
! ($token->type === Token::TYPE_NUMBER
|
||||
|| ($token->type === Token::TYPE_SYMBOL && ($token->flags & Token::FLAG_SYMBOL_PARAMETER)))
|
||||
) {
|
||||
break;
|
||||
}
|
||||
|
||||
if ($offset) {
|
||||
$ret->offset = $token->value;
|
||||
$offset = false;
|
||||
} else {
|
||||
$ret->rowCount = $token->value;
|
||||
}
|
||||
}
|
||||
|
||||
if ($offset) {
|
||||
$parser->error('An offset was expected.', $list->tokens[$list->idx - 1]);
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Limit $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
return $component->offset . ', ' . $component->rowCount;
|
||||
}
|
||||
}
|
||||
+206
@@ -0,0 +1,206 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
|
||||
/**
|
||||
* Parses a reference to a LOCK expression.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class LockExpression extends Component
|
||||
{
|
||||
/**
|
||||
* The table to be locked.
|
||||
*
|
||||
* @var Expression
|
||||
*/
|
||||
public $table;
|
||||
|
||||
/**
|
||||
* The type of lock to be applied.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return LockExpression
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------- [ tbl_name ] -----------------> 1
|
||||
* 1 ---------------- [ lock_type ] ----------------> 2
|
||||
* 2 -------------------- [ , ] --------------------> break
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
$prevToken = null;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if (
|
||||
$token->type === Token::TYPE_DELIMITER
|
||||
|| ($token->type === Token::TYPE_OPERATOR
|
||||
&& $token->value === ',')
|
||||
) {
|
||||
break;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$ret->table = Expression::parse($parser, $list, ['parseField' => 'table']);
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
// parse lock type
|
||||
$ret->type = self::parseLockType($parser, $list);
|
||||
$state = 2;
|
||||
}
|
||||
|
||||
$prevToken = $token;
|
||||
}
|
||||
|
||||
// 2 is the only valid end state
|
||||
if ($state !== 2) {
|
||||
$parser->error('Unexpected end of LOCK expression.', $prevToken);
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param LockExpression|LockExpression[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return implode(', ', $component);
|
||||
}
|
||||
|
||||
return $component->table . ' ' . $component->type;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
private static function parseLockType(Parser $parser, TokensList $list)
|
||||
{
|
||||
$lockType = '';
|
||||
|
||||
/**
|
||||
* The state of the parser while parsing for lock type.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------- [ READ ] -----------------> 1
|
||||
* 0 ------------- [ LOW_PRIORITY ] ------------> 2
|
||||
* 0 ---------------- [ WRITE ] ----------------> 3
|
||||
* 1 ---------------- [ LOCAL ] ----------------> 3
|
||||
* 2 ---------------- [ WRITE ] ----------------> 3
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
$prevToken = null;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if (
|
||||
$token->type === Token::TYPE_DELIMITER
|
||||
|| ($token->type === Token::TYPE_OPERATOR
|
||||
&& $token->value === ',')
|
||||
) {
|
||||
--$list->idx;
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if ($token->type === Token::TYPE_WHITESPACE || $token->type === Token::TYPE_COMMENT) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// We only expect keywords
|
||||
if ($token->type !== Token::TYPE_KEYWORD) {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->keyword === 'READ') {
|
||||
$state = 1;
|
||||
} elseif ($token->keyword === 'LOW_PRIORITY') {
|
||||
$state = 2;
|
||||
} elseif ($token->keyword === 'WRITE') {
|
||||
$state = 3;
|
||||
} else {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$lockType .= $token->keyword;
|
||||
} elseif ($state === 1) {
|
||||
if ($token->keyword !== 'LOCAL') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$lockType .= ' ' . $token->keyword;
|
||||
$state = 3;
|
||||
} elseif ($state === 2) {
|
||||
if ($token->keyword !== 'WRITE') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$lockType .= ' ' . $token->keyword;
|
||||
$state = 3; // parsing over
|
||||
}
|
||||
|
||||
$prevToken = $token;
|
||||
}
|
||||
|
||||
// Only two possible end states
|
||||
if ($state !== 1 && $state !== 3) {
|
||||
$parser->error('Unexpected end of LOCK expression.', $prevToken);
|
||||
}
|
||||
|
||||
return $lockType;
|
||||
}
|
||||
}
|
||||
+381
@@ -0,0 +1,381 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
use PhpMyAdmin\SqlParser\Translator;
|
||||
|
||||
use function array_merge_recursive;
|
||||
use function count;
|
||||
use function implode;
|
||||
use function is_array;
|
||||
use function ksort;
|
||||
use function sprintf;
|
||||
use function strcasecmp;
|
||||
use function strtoupper;
|
||||
|
||||
/**
|
||||
* Parses a list of options.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class OptionsArray extends Component
|
||||
{
|
||||
/**
|
||||
* ArrayObj of selected options.
|
||||
*
|
||||
* @var array<int, mixed>
|
||||
*/
|
||||
public $options = [];
|
||||
|
||||
/**
|
||||
* @param array<int, mixed> $options The array of options. Options that have a value
|
||||
* must be an array with at least two keys `name` and
|
||||
* `expr` or `value`.
|
||||
*/
|
||||
public function __construct(array $options = [])
|
||||
{
|
||||
$this->options = $options;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return OptionsArray
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* The ID that will be assigned to duplicate options.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$lastAssignedId = count($options) + 1;
|
||||
|
||||
/**
|
||||
* The option that was processed last time.
|
||||
*/
|
||||
$lastOption = null;
|
||||
|
||||
/**
|
||||
* The index of the option that was processed last time.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$lastOptionId = 0;
|
||||
|
||||
/**
|
||||
* Counts brackets.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$brackets = 0;
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------------[ option ]----------------------> 1
|
||||
*
|
||||
* 1 -------------------[ = (optional) ]------------------> 2
|
||||
*
|
||||
* 2 ----------------------[ value ]----------------------> 0
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$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 whitespace if not parsing value.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) && ($brackets === 0)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($lastOption === null) {
|
||||
$upper = strtoupper($token->token);
|
||||
if (! isset($options[$upper])) {
|
||||
// There is no option to be processed.
|
||||
break;
|
||||
}
|
||||
|
||||
$lastOption = $options[$upper];
|
||||
$lastOptionId = is_array($lastOption) ?
|
||||
$lastOption[0] : $lastOption;
|
||||
$state = 0;
|
||||
|
||||
// Checking for option conflicts.
|
||||
// For example, in `SELECT` statements the keywords `ALL`
|
||||
// and `DISTINCT` conflict and if used together, they
|
||||
// produce an invalid query.
|
||||
//
|
||||
// Usually, tokens can be identified in the array by the
|
||||
// option ID, but if conflicts occur, a generated option ID
|
||||
// is used.
|
||||
//
|
||||
// The first pseudo duplicate ID is the maximum value of the
|
||||
// real options (e.g. if there are 5 options, the first
|
||||
// fake ID is 6).
|
||||
if (isset($ret->options[$lastOptionId])) {
|
||||
$parser->error(
|
||||
sprintf(
|
||||
Translator::gettext('This option conflicts with "%1$s".'),
|
||||
is_array($ret->options[$lastOptionId])
|
||||
? $ret->options[$lastOptionId]['name']
|
||||
: $ret->options[$lastOptionId]
|
||||
),
|
||||
$token
|
||||
);
|
||||
$lastOptionId = $lastAssignedId++;
|
||||
}
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if (! is_array($lastOption)) {
|
||||
// This is a just keyword option without any value.
|
||||
// This is the beginning and the end of it.
|
||||
$ret->options[$lastOptionId] = $token->value;
|
||||
$lastOption = null;
|
||||
$state = 0;
|
||||
} elseif (($lastOption[1] === 'var') || ($lastOption[1] === 'var=')) {
|
||||
// This is a keyword that is followed by a value.
|
||||
// This is only the beginning. The value is parsed in state
|
||||
// 1 and 2. State 1 is used to skip the first equals sign
|
||||
// and state 2 to parse the actual value.
|
||||
$ret->options[$lastOptionId] = [
|
||||
// @var string The name of the option.
|
||||
'name' => $token->value,
|
||||
// @var bool Whether it contains an equal sign.
|
||||
// This is used by the builder to rebuild it.
|
||||
'equals' => $lastOption[1] === 'var=',
|
||||
// @var string Raw value.
|
||||
'expr' => '',
|
||||
// @var string Processed value.
|
||||
'value' => '',
|
||||
];
|
||||
$state = 1;
|
||||
} elseif ($lastOption[1] === 'expr' || $lastOption[1] === 'expr=') {
|
||||
// This is a keyword that is followed by an expression.
|
||||
// The expression is used by the specialized parser.
|
||||
|
||||
// Skipping this option in order to parse the expression.
|
||||
++$list->idx;
|
||||
$ret->options[$lastOptionId] = [
|
||||
// @var string The name of the option.
|
||||
'name' => $token->value,
|
||||
// @var bool Whether it contains an equal sign.
|
||||
// This is used by the builder to rebuild it.
|
||||
'equals' => $lastOption[1] === 'expr=',
|
||||
// @var Expression The parsed expression.
|
||||
'expr' => '',
|
||||
];
|
||||
$state = 1;
|
||||
}
|
||||
} elseif ($state === 1) {
|
||||
$state = 2;
|
||||
if ($token->token === '=') {
|
||||
$ret->options[$lastOptionId]['equals'] = true;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// This is outside the `elseif` group above because the change might
|
||||
// change this iteration.
|
||||
if ($state !== 2) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($lastOption[1] === 'expr' || $lastOption[1] === 'expr=') {
|
||||
$ret->options[$lastOptionId]['expr'] = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
empty($lastOption[2]) ? [] : $lastOption[2]
|
||||
);
|
||||
if ($ret->options[$lastOptionId]['expr'] !== null) {
|
||||
$ret->options[$lastOptionId]['value']
|
||||
= $ret->options[$lastOptionId]['expr']->expr;
|
||||
}
|
||||
|
||||
$lastOption = null;
|
||||
$state = 0;
|
||||
} else {
|
||||
if ($token->token === '(') {
|
||||
++$brackets;
|
||||
} elseif ($token->token === ')') {
|
||||
--$brackets;
|
||||
}
|
||||
|
||||
$ret->options[$lastOptionId]['expr'] .= $token->token;
|
||||
|
||||
if (
|
||||
! (($token->token === '(') && ($brackets === 1)
|
||||
|| (($token->token === ')') && ($brackets === 0)))
|
||||
) {
|
||||
// First pair of brackets is being skipped.
|
||||
$ret->options[$lastOptionId]['value'] .= $token->value;
|
||||
}
|
||||
|
||||
// Checking if we finished parsing.
|
||||
if ($brackets === 0) {
|
||||
$lastOption = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* We reached the end of statement without getting a value
|
||||
* for an option for which a value was required
|
||||
*/
|
||||
if (
|
||||
$state === 1
|
||||
&& $lastOption
|
||||
&& ($lastOption[1] === 'expr'
|
||||
|| $lastOption[1] === 'var'
|
||||
|| $lastOption[1] === 'var='
|
||||
|| $lastOption[1] === 'expr=')
|
||||
) {
|
||||
$parser->error(
|
||||
sprintf(
|
||||
'Value/Expression for the option %1$s was expected.',
|
||||
$ret->options[$lastOptionId]['name']
|
||||
),
|
||||
$list->tokens[$list->idx - 1]
|
||||
);
|
||||
}
|
||||
|
||||
if (empty($options['_UNSORTED'])) {
|
||||
ksort($ret->options);
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param OptionsArray $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (empty($component->options)) {
|
||||
return '';
|
||||
}
|
||||
|
||||
$options = [];
|
||||
foreach ($component->options as $option) {
|
||||
if (! is_array($option)) {
|
||||
$options[] = $option;
|
||||
} else {
|
||||
$options[] = $option['name']
|
||||
. (! empty($option['equals']) && $option['equals'] ? '=' : ' ')
|
||||
. (! empty($option['expr']) ? $option['expr'] : $option['value']);
|
||||
}
|
||||
}
|
||||
|
||||
return implode(' ', $options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if it has the specified option and returns it value or true.
|
||||
*
|
||||
* @param string $key the key to be checked
|
||||
* @param bool $getExpr Gets the expression instead of the value.
|
||||
* The value is the processed form of the expression.
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
public function has($key, $getExpr = false)
|
||||
{
|
||||
foreach ($this->options as $option) {
|
||||
if (is_array($option)) {
|
||||
if (! strcasecmp($key, $option['name'])) {
|
||||
return $getExpr ? $option['expr'] : $option['value'];
|
||||
}
|
||||
} elseif (! strcasecmp($key, $option)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the option from the array.
|
||||
*
|
||||
* @param string $key the key to be removed
|
||||
*
|
||||
* @return bool whether the key was found and deleted or not
|
||||
*/
|
||||
public function remove($key)
|
||||
{
|
||||
foreach ($this->options as $idx => $option) {
|
||||
if (is_array($option)) {
|
||||
if (! strcasecmp($key, $option['name'])) {
|
||||
unset($this->options[$idx]);
|
||||
|
||||
return true;
|
||||
}
|
||||
} elseif (! strcasecmp($key, $option)) {
|
||||
unset($this->options[$idx]);
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Merges the specified options with these ones. Values with same ID will be
|
||||
* replaced.
|
||||
*
|
||||
* @param array<int, mixed>|OptionsArray $options the options to be merged
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function merge($options)
|
||||
{
|
||||
if (is_array($options)) {
|
||||
$this->options = array_merge_recursive($this->options, $options);
|
||||
} elseif ($options instanceof self) {
|
||||
$this->options = array_merge_recursive($this->options, $options->options);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks tf there are no options set.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function isEmpty()
|
||||
{
|
||||
return empty($this->options);
|
||||
}
|
||||
}
|
||||
+135
@@ -0,0 +1,135 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
|
||||
/**
|
||||
* `ORDER BY` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class OrderKeyword extends Component
|
||||
{
|
||||
/**
|
||||
* The expression that is used for ordering.
|
||||
*
|
||||
* @var Expression
|
||||
*/
|
||||
public $expr;
|
||||
|
||||
/**
|
||||
* The order type.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* @param Expression $expr the expression that we are sorting by
|
||||
* @param string $type the sorting type
|
||||
*/
|
||||
public function __construct($expr = null, $type = 'ASC')
|
||||
{
|
||||
$this->expr = $expr;
|
||||
$this->type = $type;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return OrderKeyword[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
$expr = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 --------------------[ expression ]-------------------> 1
|
||||
*
|
||||
* 1 ------------------------[ , ]------------------------> 0
|
||||
* 1 -------------------[ ASC / DESC ]--------------------> 1
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$expr->expr = Expression::parse($parser, $list);
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if (
|
||||
($token->type === Token::TYPE_KEYWORD)
|
||||
&& (($token->keyword === 'ASC') || ($token->keyword === 'DESC'))
|
||||
) {
|
||||
$expr->type = $token->keyword;
|
||||
} elseif (($token->type === Token::TYPE_OPERATOR) && ($token->value === ',')) {
|
||||
if (! empty($expr->expr)) {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
$expr = new static();
|
||||
$state = 0;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Last iteration was not processed.
|
||||
if (! empty($expr->expr)) {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param OrderKeyword|OrderKeyword[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return implode(', ', $component);
|
||||
}
|
||||
|
||||
return $component->expr . ' ' . $component->type;
|
||||
}
|
||||
}
|
||||
+168
@@ -0,0 +1,168 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* The definition of a parameter of a function or procedure.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class ParameterDefinition extends Component
|
||||
{
|
||||
/**
|
||||
* The name of the new column.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $name;
|
||||
|
||||
/**
|
||||
* Parameter's direction (IN, OUT or INOUT).
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $inOut;
|
||||
|
||||
/**
|
||||
* The data type of thew new column.
|
||||
*
|
||||
* @var DataType
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* @param string $name parameter's name
|
||||
* @param string $inOut parameter's directional type (IN / OUT or None)
|
||||
* @param DataType $type parameter's type
|
||||
*/
|
||||
public function __construct($name = null, $inOut = null, $type = null)
|
||||
{
|
||||
$this->name = $name;
|
||||
$this->inOut = $inOut;
|
||||
$this->type = $type;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return ParameterDefinition[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
$expr = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 -----------------------[ ( ]------------------------> 1
|
||||
*
|
||||
* 1 ----------------[ IN / OUT / INOUT ]----------------> 1
|
||||
* 1 ----------------------[ name ]----------------------> 2
|
||||
*
|
||||
* 2 -------------------[ data type ]--------------------> 3
|
||||
*
|
||||
* 3 ------------------------[ , ]-----------------------> 1
|
||||
* 3 ------------------------[ ) ]-----------------------> (END)
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
|
||||
$state = 1;
|
||||
}
|
||||
|
||||
continue;
|
||||
} elseif ($state === 1) {
|
||||
if (($token->value === 'IN') || ($token->value === 'OUT') || ($token->value === 'INOUT')) {
|
||||
$expr->inOut = $token->value;
|
||||
++$list->idx;
|
||||
} elseif ($token->value === ')') {
|
||||
++$list->idx;
|
||||
break;
|
||||
} else {
|
||||
$expr->name = $token->value;
|
||||
$state = 2;
|
||||
}
|
||||
} elseif ($state === 2) {
|
||||
$expr->type = DataType::parse($parser, $list);
|
||||
$state = 3;
|
||||
} elseif ($state === 3) {
|
||||
$ret[] = $expr;
|
||||
$expr = new static();
|
||||
if ($token->value === ',') {
|
||||
$state = 1;
|
||||
} elseif ($token->value === ')') {
|
||||
++$list->idx;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Last iteration was not saved.
|
||||
if (isset($expr->name) && ($expr->name !== '')) {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param ParameterDefinition[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return '(' . implode(', ', $component) . ')';
|
||||
}
|
||||
|
||||
$tmp = '';
|
||||
if (! empty($component->inOut)) {
|
||||
$tmp .= $component->inOut . ' ';
|
||||
}
|
||||
|
||||
return trim(
|
||||
$tmp . Context::escape($component->name) . ' ' . $component->type
|
||||
);
|
||||
}
|
||||
}
|
||||
+253
@@ -0,0 +1,253 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* Parses the create definition of a partition.
|
||||
*
|
||||
* Used for parsing `CREATE TABLE` statement.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class PartitionDefinition extends Component
|
||||
{
|
||||
/**
|
||||
* All field options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'STORAGE ENGINE' => [
|
||||
1,
|
||||
'var',
|
||||
],
|
||||
'ENGINE' => [
|
||||
1,
|
||||
'var',
|
||||
],
|
||||
'COMMENT' => [
|
||||
2,
|
||||
'var',
|
||||
],
|
||||
'DATA DIRECTORY' => [
|
||||
3,
|
||||
'var',
|
||||
],
|
||||
'INDEX DIRECTORY' => [
|
||||
4,
|
||||
'var',
|
||||
],
|
||||
'MAX_ROWS' => [
|
||||
5,
|
||||
'var',
|
||||
],
|
||||
'MIN_ROWS' => [
|
||||
6,
|
||||
'var',
|
||||
],
|
||||
'TABLESPACE' => [
|
||||
7,
|
||||
'var',
|
||||
],
|
||||
'NODEGROUP' => [
|
||||
8,
|
||||
'var',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* Whether this entry is a subpartition or a partition.
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
public $isSubpartition;
|
||||
|
||||
/**
|
||||
* The name of this partition.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $name;
|
||||
|
||||
/**
|
||||
* The type of this partition (what follows the `VALUES` keyword).
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* The expression used to defined this partition.
|
||||
*
|
||||
* @var Expression|string
|
||||
*/
|
||||
public $expr;
|
||||
|
||||
/**
|
||||
* The subpartitions of this partition.
|
||||
*
|
||||
* @var PartitionDefinition[]
|
||||
*/
|
||||
public $subpartitions;
|
||||
|
||||
/**
|
||||
* The options of this field.
|
||||
*
|
||||
* @var OptionsArray
|
||||
*/
|
||||
public $options;
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return PartitionDefinition
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 -------------[ PARTITION | SUBPARTITION ]------------> 1
|
||||
*
|
||||
* 1 -----------------------[ name ]----------------------> 2
|
||||
*
|
||||
* 2 ----------------------[ VALUES ]---------------------> 3
|
||||
*
|
||||
* 3 ---------------------[ LESS THAN ]-------------------> 4
|
||||
* 3 ------------------------[ IN ]-----------------------> 4
|
||||
*
|
||||
* 4 -----------------------[ expr ]----------------------> 5
|
||||
*
|
||||
* 5 ----------------------[ options ]--------------------> 6
|
||||
*
|
||||
* 6 ------------------[ subpartitions ]------------------> (END)
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$ret->isSubpartition = ($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'SUBPARTITION');
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
$ret->name = $token->value;
|
||||
|
||||
// Looking ahead for a 'VALUES' keyword.
|
||||
// Loop until the end of the partition name (delimited by a whitespace)
|
||||
while ($nextToken = $list->tokens[++$list->idx]) {
|
||||
if ($nextToken->type !== Token::TYPE_NONE) {
|
||||
break;
|
||||
}
|
||||
|
||||
$ret->name .= $nextToken->value;
|
||||
}
|
||||
|
||||
$idx = $list->idx--;
|
||||
// Get the first token after the white space.
|
||||
$nextToken = $list->tokens[++$idx];
|
||||
|
||||
$state = ($nextToken->type === Token::TYPE_KEYWORD)
|
||||
&& ($nextToken->value === 'VALUES')
|
||||
? 2 : 5;
|
||||
} elseif ($state === 2) {
|
||||
$state = 3;
|
||||
} elseif ($state === 3) {
|
||||
$ret->type = $token->value;
|
||||
$state = 4;
|
||||
} elseif ($state === 4) {
|
||||
if ($token->value === 'MAXVALUE') {
|
||||
$ret->expr = $token->value;
|
||||
} else {
|
||||
$ret->expr = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
[
|
||||
'parenthesesDelimited' => true,
|
||||
'breakOnAlias' => true,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
$state = 5;
|
||||
} elseif ($state === 5) {
|
||||
$ret->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
$state = 6;
|
||||
} elseif ($state === 6) {
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '(')) {
|
||||
$ret->subpartitions = ArrayObj::parse(
|
||||
$parser,
|
||||
$list,
|
||||
['type' => 'PhpMyAdmin\\SqlParser\\Components\\PartitionDefinition']
|
||||
);
|
||||
++$list->idx;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param PartitionDefinition|PartitionDefinition[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return "(\n" . implode(",\n", $component) . "\n)";
|
||||
}
|
||||
|
||||
if ($component->isSubpartition) {
|
||||
return trim('SUBPARTITION ' . $component->name . ' ' . $component->options);
|
||||
}
|
||||
|
||||
$subpartitions = empty($component->subpartitions) ? '' : ' ' . self::build($component->subpartitions);
|
||||
|
||||
return trim(
|
||||
'PARTITION ' . $component->name
|
||||
. (empty($component->type) ? '' : ' VALUES ' . $component->type . ' ' . $component->expr . ' ')
|
||||
. (! empty($component->options) && ! empty($component->type) ? '' : ' ')
|
||||
. $component->options . $subpartitions
|
||||
);
|
||||
}
|
||||
}
|
||||
+158
@@ -0,0 +1,158 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `REFERENCES` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class Reference extends Component
|
||||
{
|
||||
/**
|
||||
* All references options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $REFERENCES_OPTIONS = [
|
||||
'MATCH' => [
|
||||
1,
|
||||
'var',
|
||||
],
|
||||
'ON DELETE' => [
|
||||
2,
|
||||
'var',
|
||||
],
|
||||
'ON UPDATE' => [
|
||||
3,
|
||||
'var',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* The referenced table.
|
||||
*
|
||||
* @var Expression
|
||||
*/
|
||||
public $table;
|
||||
|
||||
/**
|
||||
* The referenced columns.
|
||||
*
|
||||
* @var string[]
|
||||
*/
|
||||
public $columns;
|
||||
|
||||
/**
|
||||
* The options of the referencing.
|
||||
*
|
||||
* @var OptionsArray
|
||||
*/
|
||||
public $options;
|
||||
|
||||
/**
|
||||
* @param Expression $table the name of the table referenced
|
||||
* @param string[] $columns the columns referenced
|
||||
* @param OptionsArray $options the options
|
||||
*/
|
||||
public function __construct($table = null, array $columns = [], $options = null)
|
||||
{
|
||||
$this->table = $table;
|
||||
$this->columns = $columns;
|
||||
$this->options = $options;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return Reference
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ----------------------[ table ]---------------------> 1
|
||||
*
|
||||
* 1 ---------------------[ columns ]--------------------> 2
|
||||
*
|
||||
* 2 ---------------------[ options ]--------------------> (END)
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$ret->table = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
[
|
||||
'parseField' => 'table',
|
||||
'breakOnAlias' => true,
|
||||
]
|
||||
);
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
$ret->columns = ArrayObj::parse($parser, $list)->values;
|
||||
$state = 2;
|
||||
} elseif ($state === 2) {
|
||||
$ret->options = OptionsArray::parse($parser, $list, static::$REFERENCES_OPTIONS);
|
||||
++$list->idx;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Reference $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
return trim(
|
||||
$component->table
|
||||
. ' (' . implode(', ', Context::escape($component->columns)) . ') '
|
||||
. $component->options
|
||||
);
|
||||
}
|
||||
}
|
||||
+167
@@ -0,0 +1,167 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function is_array;
|
||||
|
||||
/**
|
||||
* `RENAME TABLE` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class RenameOperation extends Component
|
||||
{
|
||||
/**
|
||||
* The old table name.
|
||||
*
|
||||
* @var Expression
|
||||
*/
|
||||
public $old;
|
||||
|
||||
/**
|
||||
* The new table name.
|
||||
*
|
||||
* @var Expression
|
||||
*/
|
||||
public $new;
|
||||
|
||||
/**
|
||||
* @param Expression $old old expression
|
||||
* @param Expression $new new expression containing new name
|
||||
*/
|
||||
public function __construct($old = null, $new = null)
|
||||
{
|
||||
$this->old = $old;
|
||||
$this->new = $new;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return RenameOperation[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
$expr = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------------[ old name ]--------------------> 1
|
||||
*
|
||||
* 1 ------------------------[ TO ]-----------------------> 2
|
||||
*
|
||||
* 2 ---------------------[ new name ]--------------------> 3
|
||||
*
|
||||
* 3 ------------------------[ , ]------------------------> 0
|
||||
* 3 -----------------------[ else ]----------------------> (END)
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$expr->old = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
[
|
||||
'breakOnAlias' => true,
|
||||
'parseField' => 'table',
|
||||
]
|
||||
);
|
||||
if (empty($expr->old)) {
|
||||
$parser->error('The old name of the table was expected.', $token);
|
||||
}
|
||||
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if ($token->type !== Token::TYPE_KEYWORD || $token->keyword !== 'TO') {
|
||||
$parser->error('Keyword "TO" was expected.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$state = 2;
|
||||
} elseif ($state === 2) {
|
||||
$expr->new = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
[
|
||||
'breakOnAlias' => true,
|
||||
'parseField' => 'table',
|
||||
]
|
||||
);
|
||||
if (empty($expr->new)) {
|
||||
$parser->error('The new name of the table was expected.', $token);
|
||||
}
|
||||
|
||||
$state = 3;
|
||||
} elseif ($state === 3) {
|
||||
if (($token->type !== Token::TYPE_OPERATOR) || ($token->value !== ',')) {
|
||||
break;
|
||||
}
|
||||
|
||||
$ret[] = $expr;
|
||||
$expr = new static();
|
||||
$state = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if ($state !== 3) {
|
||||
$parser->error('A rename operation was expected.', $list->tokens[$list->idx - 1]);
|
||||
}
|
||||
|
||||
// Last iteration was not saved.
|
||||
if (! empty($expr->old)) {
|
||||
$ret[] = $expr;
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param RenameOperation $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return implode(', ', $component);
|
||||
}
|
||||
|
||||
return $component->old . ' TO ' . $component->new;
|
||||
}
|
||||
}
|
||||
+159
@@ -0,0 +1,159 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function in_array;
|
||||
use function is_array;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `SET` keyword parser.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class SetOperation extends Component
|
||||
{
|
||||
/**
|
||||
* The name of the column that is being updated.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $column;
|
||||
|
||||
/**
|
||||
* The new value.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $value;
|
||||
|
||||
/**
|
||||
* @param string $column Field's name..
|
||||
* @param string $value new value
|
||||
*/
|
||||
public function __construct($column = '', $value = '')
|
||||
{
|
||||
$this->column = $column;
|
||||
$this->value = $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the parser that serves as context
|
||||
* @param TokensList $list the list of tokens that are being parsed
|
||||
* @param array<string, mixed> $options parameters for parsing
|
||||
*
|
||||
* @return SetOperation[]
|
||||
*/
|
||||
public static function parse(Parser $parser, TokensList $list, array $options = [])
|
||||
{
|
||||
$ret = [];
|
||||
|
||||
$expr = new static();
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------------[ col_name ]--------------------> 0
|
||||
* 0 ---------------------[ = or := ]---------------------> 1
|
||||
* 1 -----------------------[ value ]---------------------> 1
|
||||
* 1 ------------------------[ , ]------------------------> 0
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
/**
|
||||
* Token when the parser has seen the latest comma
|
||||
*
|
||||
* @var Token
|
||||
*/
|
||||
$commaLastSeenAt = null;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// No keyword is expected.
|
||||
if (
|
||||
($token->type === Token::TYPE_KEYWORD)
|
||||
&& ($token->flags & Token::FLAG_KEYWORD_RESERVED)
|
||||
&& ($state === 0)
|
||||
) {
|
||||
break;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if (in_array($token->token, ['=', ':='], true)) {
|
||||
$state = 1;
|
||||
} elseif ($token->value !== ',') {
|
||||
$expr->column .= $token->token;
|
||||
} elseif ($token->value === ',') {
|
||||
$commaLastSeenAt = $token;
|
||||
}
|
||||
} elseif ($state === 1) {
|
||||
$tmp = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
['breakOnAlias' => true]
|
||||
);
|
||||
if ($tmp === null) {
|
||||
$parser->error('Missing expression.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$expr->column = trim($expr->column);
|
||||
$expr->value = $tmp->expr;
|
||||
$ret[] = $expr;
|
||||
$expr = new static();
|
||||
$state = 0;
|
||||
$commaLastSeenAt = null;
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
|
||||
// We saw a comma, but didn't see a column-value pair after it
|
||||
if ($commaLastSeenAt !== null) {
|
||||
$parser->error('Unexpected token.', $commaLastSeenAt);
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param SetOperation|SetOperation[] $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (is_array($component)) {
|
||||
return implode(', ', $component);
|
||||
}
|
||||
|
||||
return $component->column . ' = ' . $component->value;
|
||||
}
|
||||
}
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
|
||||
use function implode;
|
||||
|
||||
/**
|
||||
* `UNION` keyword builder.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
class UnionKeyword extends Component
|
||||
{
|
||||
/**
|
||||
* @param array<UnionKeyword[]> $component the component to be built
|
||||
* @param array<string, mixed> $options parameters for building
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
$tmp = [];
|
||||
foreach ($component as $componentPart) {
|
||||
$tmp[] = $componentPart[0] . ' ' . $componentPart[1];
|
||||
}
|
||||
|
||||
return implode(' ', $tmp);
|
||||
}
|
||||
}
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Components;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Component;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use RuntimeException;
|
||||
|
||||
/**
|
||||
* `WITH` keyword builder.
|
||||
*
|
||||
* @final
|
||||
*/
|
||||
final class WithKeyword extends Component
|
||||
{
|
||||
/** @var string */
|
||||
public $name;
|
||||
|
||||
/** @var ArrayObj[] */
|
||||
public $columns = [];
|
||||
|
||||
/** @var Parser|null */
|
||||
public $statement;
|
||||
|
||||
public function __construct(string $name)
|
||||
{
|
||||
$this->name = $name;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param WithKeyword $component
|
||||
* @param array<string, mixed> $options
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($component, array $options = [])
|
||||
{
|
||||
if (! $component instanceof WithKeyword) {
|
||||
throw new RuntimeException('Can not build a component that is not a WithKeyword');
|
||||
}
|
||||
|
||||
if (! isset($component->statement)) {
|
||||
throw new RuntimeException('No statement inside WITH');
|
||||
}
|
||||
|
||||
$str = $component->name;
|
||||
|
||||
if ($component->columns) {
|
||||
$str .= ArrayObj::build($component->columns);
|
||||
}
|
||||
|
||||
$str .= ' AS (';
|
||||
|
||||
foreach ($component->statement->statements as $statement) {
|
||||
$str .= $statement->build();
|
||||
}
|
||||
|
||||
$str .= ')';
|
||||
|
||||
return $str;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,862 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Exceptions\LoaderException;
|
||||
|
||||
use function class_exists;
|
||||
use function explode;
|
||||
use function intval;
|
||||
use function is_array;
|
||||
use function is_int;
|
||||
use function is_numeric;
|
||||
use function str_replace;
|
||||
use function str_starts_with;
|
||||
use function strlen;
|
||||
use function strtoupper;
|
||||
use function substr;
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
* Holds the configuration of the context that is currently used.
|
||||
*/
|
||||
abstract class Context
|
||||
{
|
||||
/**
|
||||
* The maximum length of a keyword.
|
||||
*
|
||||
* @see static::$TOKEN_KEYWORD
|
||||
*/
|
||||
public 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
|
||||
*/
|
||||
public const LABEL_MAX_LENGTH = 16;
|
||||
|
||||
/**
|
||||
* The maximum length of an operator.
|
||||
*
|
||||
* @see static::$TOKEN_OPERATOR
|
||||
*/
|
||||
public 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<string,int>
|
||||
* @phpstan-var non-empty-array<non-empty-string,Token::FLAG_KEYWORD_*|int>
|
||||
*/
|
||||
public static $KEYWORDS = [];
|
||||
|
||||
/**
|
||||
* List of operators and their flags.
|
||||
*
|
||||
* @var array<string, int>
|
||||
*/
|
||||
public static $OPERATORS = [
|
||||
// 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.
|
||||
*
|
||||
* @internal use the {@see Context::getMode()} method instead.
|
||||
*
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html
|
||||
* @link https://mariadb.com/kb/en/sql-mode/
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
public static $MODE = self::SQL_MODE_NONE;
|
||||
|
||||
public const SQL_MODE_NONE = 0;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_allow_invalid_dates
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#allow_invalid_dates
|
||||
*/
|
||||
public const SQL_MODE_ALLOW_INVALID_DATES = 1;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_ansi_quotes
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#ansi_quotes
|
||||
*/
|
||||
public const SQL_MODE_ANSI_QUOTES = 2;
|
||||
|
||||
/** Compatibility mode for Microsoft's SQL server. This is the equivalent of {@see SQL_MODE_ANSI_QUOTES}. */
|
||||
public const SQL_MODE_COMPAT_MYSQL = 2;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_error_for_division_by_zero
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#error_for_division_by_zero
|
||||
*/
|
||||
public const SQL_MODE_ERROR_FOR_DIVISION_BY_ZERO = 4;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_high_not_precedence
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#high_not_precedence
|
||||
*/
|
||||
public const SQL_MODE_HIGH_NOT_PRECEDENCE = 8;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_ignore_space
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#ignore_space
|
||||
*/
|
||||
public const SQL_MODE_IGNORE_SPACE = 16;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_no_auto_create_user
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_auto_create_user
|
||||
*/
|
||||
public const SQL_MODE_NO_AUTO_CREATE_USER = 32;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_no_auto_value_on_zero
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_auto_value_on_zero
|
||||
*/
|
||||
public const SQL_MODE_NO_AUTO_VALUE_ON_ZERO = 64;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_no_backslash_escapes
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_backslash_escapes
|
||||
*/
|
||||
public const SQL_MODE_NO_BACKSLASH_ESCAPES = 128;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_no_dir_in_create
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_dir_in_create
|
||||
*/
|
||||
public const SQL_MODE_NO_DIR_IN_CREATE = 256;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_no_engine_substitution
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_engine_substitution
|
||||
*/
|
||||
public const SQL_MODE_NO_ENGINE_SUBSTITUTION = 512;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_no_field_options
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_field_options
|
||||
*/
|
||||
public const SQL_MODE_NO_FIELD_OPTIONS = 1024;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_no_key_options
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_key_options
|
||||
*/
|
||||
public const SQL_MODE_NO_KEY_OPTIONS = 2048;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_no_table_options
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_table_options
|
||||
*/
|
||||
public const SQL_MODE_NO_TABLE_OPTIONS = 4096;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_no_unsigned_subtraction
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_unsigned_subtraction
|
||||
*/
|
||||
public const SQL_MODE_NO_UNSIGNED_SUBTRACTION = 8192;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_no_zero_date
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_zero_date
|
||||
*/
|
||||
public const SQL_MODE_NO_ZERO_DATE = 16384;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_no_zero_in_date
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#no_zero_in_date
|
||||
*/
|
||||
public const SQL_MODE_NO_ZERO_IN_DATE = 32768;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_only_full_group_by
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#only_full_group_by
|
||||
*/
|
||||
public const SQL_MODE_ONLY_FULL_GROUP_BY = 65536;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_pipes_as_concat
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#pipes_as_concat
|
||||
*/
|
||||
public const SQL_MODE_PIPES_AS_CONCAT = 131072;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_real_as_float
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#real_as_float
|
||||
*/
|
||||
public const SQL_MODE_REAL_AS_FLOAT = 262144;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_strict_all_tables
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#strict_all_tables
|
||||
*/
|
||||
public const SQL_MODE_STRICT_ALL_TABLES = 524288;
|
||||
|
||||
/**
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_strict_trans_tables
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#strict_trans_tables
|
||||
*/
|
||||
public const SQL_MODE_STRICT_TRANS_TABLES = 1048576;
|
||||
|
||||
/**
|
||||
* Custom mode.
|
||||
* 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.
|
||||
*/
|
||||
public const SQL_MODE_NO_ENCLOSING_QUOTES = 1073741824;
|
||||
|
||||
/**
|
||||
* Equivalent to {@see SQL_MODE_REAL_AS_FLOAT}, {@see SQL_MODE_PIPES_AS_CONCAT}, {@see SQL_MODE_ANSI_QUOTES},
|
||||
* {@see SQL_MODE_IGNORE_SPACE}.
|
||||
*
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_ansi
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#ansi
|
||||
*/
|
||||
public const SQL_MODE_ANSI = 393234;
|
||||
|
||||
/**
|
||||
* Equivalent to {@see SQL_MODE_PIPES_AS_CONCAT}, {@see SQL_MODE_ANSI_QUOTES}, {@see SQL_MODE_IGNORE_SPACE},
|
||||
* {@see SQL_MODE_NO_KEY_OPTIONS}, {@see SQL_MODE_NO_TABLE_OPTIONS}, {@see SQL_MODE_NO_FIELD_OPTIONS}.
|
||||
*
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_db2
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#db2
|
||||
*/
|
||||
public const SQL_MODE_DB2 = 138258;
|
||||
|
||||
/**
|
||||
* Equivalent to {@see SQL_MODE_PIPES_AS_CONCAT}, {@see SQL_MODE_ANSI_QUOTES}, {@see SQL_MODE_IGNORE_SPACE},
|
||||
* {@see SQL_MODE_NO_KEY_OPTIONS}, {@see SQL_MODE_NO_TABLE_OPTIONS}, {@see SQL_MODE_NO_FIELD_OPTIONS},
|
||||
* {@see SQL_MODE_NO_AUTO_CREATE_USER}.
|
||||
*
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_maxdb
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#maxdb
|
||||
*/
|
||||
public const SQL_MODE_MAXDB = 138290;
|
||||
|
||||
/**
|
||||
* Equivalent to {@see SQL_MODE_PIPES_AS_CONCAT}, {@see SQL_MODE_ANSI_QUOTES}, {@see SQL_MODE_IGNORE_SPACE},
|
||||
* {@see SQL_MODE_NO_KEY_OPTIONS}, {@see SQL_MODE_NO_TABLE_OPTIONS}, {@see SQL_MODE_NO_FIELD_OPTIONS}.
|
||||
*
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_mssql
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#mssql
|
||||
*/
|
||||
public const SQL_MODE_MSSQL = 138258;
|
||||
|
||||
/**
|
||||
* Equivalent to {@see SQL_MODE_PIPES_AS_CONCAT}, {@see SQL_MODE_ANSI_QUOTES}, {@see SQL_MODE_IGNORE_SPACE},
|
||||
* {@see SQL_MODE_NO_KEY_OPTIONS}, {@see SQL_MODE_NO_TABLE_OPTIONS}, {@see SQL_MODE_NO_FIELD_OPTIONS},
|
||||
* {@see SQL_MODE_NO_AUTO_CREATE_USER}.
|
||||
*
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_oracle
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#oracle
|
||||
*/
|
||||
public const SQL_MODE_ORACLE = 138290;
|
||||
|
||||
/**
|
||||
* Equivalent to {@see SQL_MODE_PIPES_AS_CONCAT}, {@see SQL_MODE_ANSI_QUOTES}, {@see SQL_MODE_IGNORE_SPACE},
|
||||
* {@see SQL_MODE_NO_KEY_OPTIONS}, {@see SQL_MODE_NO_TABLE_OPTIONS}, {@see SQL_MODE_NO_FIELD_OPTIONS}.
|
||||
*
|
||||
* @link https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_postgresql
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#postgresql
|
||||
*/
|
||||
public const SQL_MODE_POSTGRESQL = 138258;
|
||||
|
||||
/**
|
||||
* Equivalent to {@see SQL_MODE_STRICT_TRANS_TABLES}, {@see SQL_MODE_STRICT_ALL_TABLES},
|
||||
* {@see SQL_MODE_NO_ZERO_IN_DATE}, {@see SQL_MODE_NO_ZERO_DATE}, {@see SQL_MODE_ERROR_FOR_DIVISION_BY_ZERO},
|
||||
* {@see SQL_MODE_NO_AUTO_CREATE_USER}.
|
||||
*
|
||||
* @link https://dev.mysql.com/doc/refman/en/sql-mode.html#sqlmode_traditional
|
||||
* @link https://mariadb.com/kb/en/sql-mode/#traditional
|
||||
*/
|
||||
public 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;
|
||||
}
|
||||
|
||||
if ($str[0] === '`') {
|
||||
return Token::FLAG_SYMBOL_BACKTICK;
|
||||
}
|
||||
|
||||
if ($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;
|
||||
}
|
||||
|
||||
if ($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 !== '$')
|
||||
&& (($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
|
||||
*
|
||||
* @return void
|
||||
*
|
||||
* @throws LoaderException if the specified context doesn't exist.
|
||||
*/
|
||||
public static function load($context = '')
|
||||
{
|
||||
if (empty($context)) {
|
||||
$context = self::$defaultContext;
|
||||
}
|
||||
|
||||
if ($context[0] !== '\\') {
|
||||
// Could be the fully qualified class name was given, like `ContextDBMS::class`.
|
||||
if (class_exists('\\' . $context)) {
|
||||
$context = '\\' . $context;
|
||||
} else {
|
||||
// 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 (str_starts_with($context, 'MariaDb')) {
|
||||
return static::loadClosest('MariaDb100300');
|
||||
}
|
||||
|
||||
if (str_starts_with($context, 'MySql')) {
|
||||
return static::loadClosest('MySql50700');
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the SQL mode.
|
||||
*/
|
||||
public static function getMode(): int
|
||||
{
|
||||
return static::$MODE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the SQL mode.
|
||||
*
|
||||
* @param int|string $mode
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function setMode($mode = self::SQL_MODE_NONE)
|
||||
{
|
||||
if (is_int($mode)) {
|
||||
static::$MODE = $mode;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
static::$MODE = self::SQL_MODE_NONE;
|
||||
if ($mode === '') {
|
||||
return;
|
||||
}
|
||||
|
||||
$modes = explode(',', $mode);
|
||||
foreach ($modes as $sqlMode) {
|
||||
static::$MODE |= self::getModeFromString($sqlMode);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @psalm-suppress MixedReturnStatement, MixedInferredReturnType Is caused by the LSB of the constants
|
||||
*/
|
||||
private static function getModeFromString(string $mode): int
|
||||
{
|
||||
// phpcs:disable SlevomatCodingStandard.Classes.DisallowLateStaticBindingForConstants.DisallowedLateStaticBindingForConstant
|
||||
switch ($mode) {
|
||||
case 'ALLOW_INVALID_DATES':
|
||||
return static::SQL_MODE_ALLOW_INVALID_DATES;
|
||||
|
||||
case 'ANSI_QUOTES':
|
||||
return static::SQL_MODE_ANSI_QUOTES;
|
||||
|
||||
case 'COMPAT_MYSQL':
|
||||
return static::SQL_MODE_COMPAT_MYSQL;
|
||||
|
||||
case 'ERROR_FOR_DIVISION_BY_ZERO':
|
||||
return static::SQL_MODE_ERROR_FOR_DIVISION_BY_ZERO;
|
||||
|
||||
case 'HIGH_NOT_PRECEDENCE':
|
||||
return static::SQL_MODE_HIGH_NOT_PRECEDENCE;
|
||||
|
||||
case 'IGNORE_SPACE':
|
||||
return static::SQL_MODE_IGNORE_SPACE;
|
||||
|
||||
case 'NO_AUTO_CREATE_USER':
|
||||
return static::SQL_MODE_NO_AUTO_CREATE_USER;
|
||||
|
||||
case 'NO_AUTO_VALUE_ON_ZERO':
|
||||
return static::SQL_MODE_NO_AUTO_VALUE_ON_ZERO;
|
||||
|
||||
case 'NO_BACKSLASH_ESCAPES':
|
||||
return static::SQL_MODE_NO_BACKSLASH_ESCAPES;
|
||||
|
||||
case 'NO_DIR_IN_CREATE':
|
||||
return static::SQL_MODE_NO_DIR_IN_CREATE;
|
||||
|
||||
case 'NO_ENGINE_SUBSTITUTION':
|
||||
return static::SQL_MODE_NO_ENGINE_SUBSTITUTION;
|
||||
|
||||
case 'NO_FIELD_OPTIONS':
|
||||
return static::SQL_MODE_NO_FIELD_OPTIONS;
|
||||
|
||||
case 'NO_KEY_OPTIONS':
|
||||
return static::SQL_MODE_NO_KEY_OPTIONS;
|
||||
|
||||
case 'NO_TABLE_OPTIONS':
|
||||
return static::SQL_MODE_NO_TABLE_OPTIONS;
|
||||
|
||||
case 'NO_UNSIGNED_SUBTRACTION':
|
||||
return static::SQL_MODE_NO_UNSIGNED_SUBTRACTION;
|
||||
|
||||
case 'NO_ZERO_DATE':
|
||||
return static::SQL_MODE_NO_ZERO_DATE;
|
||||
|
||||
case 'NO_ZERO_IN_DATE':
|
||||
return static::SQL_MODE_NO_ZERO_IN_DATE;
|
||||
|
||||
case 'ONLY_FULL_GROUP_BY':
|
||||
return static::SQL_MODE_ONLY_FULL_GROUP_BY;
|
||||
|
||||
case 'PIPES_AS_CONCAT':
|
||||
return static::SQL_MODE_PIPES_AS_CONCAT;
|
||||
|
||||
case 'REAL_AS_FLOAT':
|
||||
return static::SQL_MODE_REAL_AS_FLOAT;
|
||||
|
||||
case 'STRICT_ALL_TABLES':
|
||||
return static::SQL_MODE_STRICT_ALL_TABLES;
|
||||
|
||||
case 'STRICT_TRANS_TABLES':
|
||||
return static::SQL_MODE_STRICT_TRANS_TABLES;
|
||||
|
||||
case 'NO_ENCLOSING_QUOTES':
|
||||
return static::SQL_MODE_NO_ENCLOSING_QUOTES;
|
||||
|
||||
case 'ANSI':
|
||||
return static::SQL_MODE_ANSI;
|
||||
|
||||
case 'DB2':
|
||||
return static::SQL_MODE_DB2;
|
||||
|
||||
case 'MAXDB':
|
||||
return static::SQL_MODE_MAXDB;
|
||||
|
||||
case 'MSSQL':
|
||||
return static::SQL_MODE_MSSQL;
|
||||
|
||||
case 'ORACLE':
|
||||
return static::SQL_MODE_ORACLE;
|
||||
|
||||
case 'POSTGRESQL':
|
||||
return static::SQL_MODE_POSTGRESQL;
|
||||
|
||||
case 'TRADITIONAL':
|
||||
return static::SQL_MODE_TRADITIONAL;
|
||||
|
||||
default:
|
||||
return self::SQL_MODE_NONE;
|
||||
}
|
||||
// phpcs:enable
|
||||
}
|
||||
|
||||
/**
|
||||
* Escapes the symbol by adding surrounding backticks.
|
||||
*
|
||||
* @param string[]|string $str the string to be escaped
|
||||
* @param string $quote quote to be used when escaping
|
||||
*
|
||||
* @return string|string[]
|
||||
*/
|
||||
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))) {
|
||||
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
|
||||
*
|
||||
* @param int $flag for example {@see Context::SQL_MODE_ANSI_QUOTES}
|
||||
*
|
||||
* @return bool false on empty param, true/false on given constant/int value
|
||||
*/
|
||||
public static function hasMode($flag = null)
|
||||
{
|
||||
if (empty($flag)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return (self::$MODE & $flag) === $flag;
|
||||
}
|
||||
}
|
||||
|
||||
// Initializing the default context.
|
||||
Context::load();
|
||||
+1014
File diff suppressed because it is too large
Load Diff
+1114
File diff suppressed because it is too large
Load Diff
+1094
File diff suppressed because it is too large
Load Diff
+1133
File diff suppressed because it is too large
Load Diff
+1172
File diff suppressed because it is too large
Load Diff
+1176
File diff suppressed because it is too large
Load Diff
+1178
File diff suppressed because it is too large
Load Diff
+1182
File diff suppressed because it is too large
Load Diff
+1183
File diff suppressed because it is too large
Load Diff
+1180
File diff suppressed because it is too large
Load Diff
+1181
File diff suppressed because it is too large
Load Diff
+1181
File diff suppressed because it is too large
Load Diff
+1182
File diff suppressed because it is too large
Load Diff
+1183
File diff suppressed because it is too large
Load Diff
+1186
File diff suppressed because it is too large
Load Diff
+1187
File diff suppressed because it is too large
Load Diff
+1187
File diff suppressed because it is too large
Load Diff
+1096
File diff suppressed because it is too large
Load Diff
+1096
File diff suppressed because it is too large
Load Diff
+1103
File diff suppressed because it is too large
Load Diff
+826
@@ -0,0 +1,826 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Contexts;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
|
||||
/**
|
||||
* Context for MySQL 5.0.
|
||||
*
|
||||
* This class was auto-generated from tools/contexts/*.txt.
|
||||
* Use tools/run_generators.sh for update.
|
||||
*
|
||||
* @see https://dev.mysql.com/doc/refman/5.0/en/keywords.html
|
||||
*/
|
||||
class ContextMySql50000 extends Context
|
||||
{
|
||||
/**
|
||||
* List of keywords.
|
||||
*
|
||||
* The value associated to each keyword represents its flags.
|
||||
*
|
||||
* @see Token
|
||||
*
|
||||
* @var array<string,int>
|
||||
* @phpstan-var non-empty-array<non-empty-string,Token::FLAG_KEYWORD_*|int>
|
||||
*/
|
||||
public static $KEYWORDS = [
|
||||
'ACTION' => Token::FLAG_KEYWORD,
|
||||
'AFTER' => Token::FLAG_KEYWORD,
|
||||
'AGGREGATE' => Token::FLAG_KEYWORD,
|
||||
'ALGORITHM' => Token::FLAG_KEYWORD,
|
||||
'ANY' => Token::FLAG_KEYWORD,
|
||||
'AUTO_INCREMENT' => Token::FLAG_KEYWORD,
|
||||
'AVG_ROW_LENGTH' => Token::FLAG_KEYWORD,
|
||||
'BACKUP' => Token::FLAG_KEYWORD,
|
||||
'BDB' => Token::FLAG_KEYWORD,
|
||||
'BEGIN' => Token::FLAG_KEYWORD,
|
||||
'BERKELEYDB' => Token::FLAG_KEYWORD,
|
||||
'BINLOG' => Token::FLAG_KEYWORD,
|
||||
'BLOCK' => Token::FLAG_KEYWORD,
|
||||
'BTREE' => Token::FLAG_KEYWORD,
|
||||
'BYTE' => Token::FLAG_KEYWORD,
|
||||
'CACHE' => Token::FLAG_KEYWORD,
|
||||
'CASCADED' => Token::FLAG_KEYWORD,
|
||||
'CHAIN' => Token::FLAG_KEYWORD,
|
||||
'CHANGED' => Token::FLAG_KEYWORD,
|
||||
'CHECKSUM' => Token::FLAG_KEYWORD,
|
||||
'CIPHER' => Token::FLAG_KEYWORD,
|
||||
'CLIENT' => Token::FLAG_KEYWORD,
|
||||
'CLOSE' => Token::FLAG_KEYWORD,
|
||||
'CODE' => Token::FLAG_KEYWORD,
|
||||
'COLUMNS' => Token::FLAG_KEYWORD,
|
||||
'COMMENT' => Token::FLAG_KEYWORD,
|
||||
'COMMIT' => Token::FLAG_KEYWORD,
|
||||
'COMMITTED' => Token::FLAG_KEYWORD,
|
||||
'COMPACT' => Token::FLAG_KEYWORD,
|
||||
'COMPRESSED' => Token::FLAG_KEYWORD,
|
||||
'CONCURRENT' => Token::FLAG_KEYWORD,
|
||||
'CONNECTION' => Token::FLAG_KEYWORD,
|
||||
'CONSISTENT' => Token::FLAG_KEYWORD,
|
||||
'CONTEXT' => Token::FLAG_KEYWORD,
|
||||
'CPU' => Token::FLAG_KEYWORD,
|
||||
'CUBE' => Token::FLAG_KEYWORD,
|
||||
'DATA' => Token::FLAG_KEYWORD,
|
||||
'DEALLOCATE' => Token::FLAG_KEYWORD,
|
||||
'DEFINER' => Token::FLAG_KEYWORD,
|
||||
'DELAY_KEY_WRITE' => Token::FLAG_KEYWORD,
|
||||
'DES_KEY_FILE' => Token::FLAG_KEYWORD,
|
||||
'DIRECTORY' => Token::FLAG_KEYWORD,
|
||||
'DISABLE' => Token::FLAG_KEYWORD,
|
||||
'DISCARD' => Token::FLAG_KEYWORD,
|
||||
'DO' => Token::FLAG_KEYWORD,
|
||||
'DUMPFILE' => Token::FLAG_KEYWORD,
|
||||
'DUPLICATE' => Token::FLAG_KEYWORD,
|
||||
'DYNAMIC' => Token::FLAG_KEYWORD,
|
||||
'ENABLE' => Token::FLAG_KEYWORD,
|
||||
'END' => Token::FLAG_KEYWORD,
|
||||
'ENGINE' => Token::FLAG_KEYWORD,
|
||||
'ENGINES' => Token::FLAG_KEYWORD,
|
||||
'ERRORS' => Token::FLAG_KEYWORD,
|
||||
'ESCAPE' => Token::FLAG_KEYWORD,
|
||||
'EVENTS' => Token::FLAG_KEYWORD,
|
||||
'EXECUTE' => Token::FLAG_KEYWORD,
|
||||
'EXPANSION' => Token::FLAG_KEYWORD,
|
||||
'EXTENDED' => Token::FLAG_KEYWORD,
|
||||
'FAST' => Token::FLAG_KEYWORD,
|
||||
'FAULTS' => Token::FLAG_KEYWORD,
|
||||
'FIELDS' => Token::FLAG_KEYWORD,
|
||||
'FILE' => Token::FLAG_KEYWORD,
|
||||
'FIRST' => Token::FLAG_KEYWORD,
|
||||
'FLUSH' => Token::FLAG_KEYWORD,
|
||||
'FOUND' => Token::FLAG_KEYWORD,
|
||||
'FRAC_SECOND' => Token::FLAG_KEYWORD,
|
||||
'FULL' => Token::FLAG_KEYWORD,
|
||||
'FUNCTION' => Token::FLAG_KEYWORD,
|
||||
'GLOBAL' => Token::FLAG_KEYWORD,
|
||||
'GRANTS' => Token::FLAG_KEYWORD,
|
||||
'HANDLER' => Token::FLAG_KEYWORD,
|
||||
'HASH' => Token::FLAG_KEYWORD,
|
||||
'HELP' => Token::FLAG_KEYWORD,
|
||||
'HOSTS' => Token::FLAG_KEYWORD,
|
||||
'IDENTIFIED' => Token::FLAG_KEYWORD,
|
||||
'IMPORT' => Token::FLAG_KEYWORD,
|
||||
'INDEXES' => Token::FLAG_KEYWORD,
|
||||
'INNOBASE' => Token::FLAG_KEYWORD,
|
||||
'INNODB' => Token::FLAG_KEYWORD,
|
||||
'INSERT_METHOD' => Token::FLAG_KEYWORD,
|
||||
'INVOKER' => Token::FLAG_KEYWORD,
|
||||
'IO' => Token::FLAG_KEYWORD,
|
||||
'IO_THREAD' => Token::FLAG_KEYWORD,
|
||||
'IPC' => Token::FLAG_KEYWORD,
|
||||
'ISOLATION' => Token::FLAG_KEYWORD,
|
||||
'ISSUER' => Token::FLAG_KEYWORD,
|
||||
'LANGUAGE' => Token::FLAG_KEYWORD,
|
||||
'LAST' => Token::FLAG_KEYWORD,
|
||||
'LEAVES' => Token::FLAG_KEYWORD,
|
||||
'LEVEL' => Token::FLAG_KEYWORD,
|
||||
'LOCAL' => Token::FLAG_KEYWORD,
|
||||
'LOCKS' => Token::FLAG_KEYWORD,
|
||||
'LOGS' => Token::FLAG_KEYWORD,
|
||||
'MASTER' => Token::FLAG_KEYWORD,
|
||||
'MASTER_CONNECT_RETRY' => Token::FLAG_KEYWORD,
|
||||
'MASTER_HOST' => Token::FLAG_KEYWORD,
|
||||
'MASTER_LOG_FILE' => Token::FLAG_KEYWORD,
|
||||
'MASTER_LOG_POS' => Token::FLAG_KEYWORD,
|
||||
'MASTER_PASSWORD' => Token::FLAG_KEYWORD,
|
||||
'MASTER_PORT' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SERVER_ID' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CA' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CAPATH' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CERT' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CIPHER' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_KEY' => Token::FLAG_KEYWORD,
|
||||
'MASTER_USER' => Token::FLAG_KEYWORD,
|
||||
'MAX_CONNECTIONS_PER_HOUR' => Token::FLAG_KEYWORD,
|
||||
'MAX_QUERIES_PER_HOUR' => Token::FLAG_KEYWORD,
|
||||
'MAX_ROWS' => Token::FLAG_KEYWORD,
|
||||
'MAX_UPDATES_PER_HOUR' => Token::FLAG_KEYWORD,
|
||||
'MAX_USER_CONNECTIONS' => Token::FLAG_KEYWORD,
|
||||
'MEDIUM' => Token::FLAG_KEYWORD,
|
||||
'MEMORY' => Token::FLAG_KEYWORD,
|
||||
'MERGE' => Token::FLAG_KEYWORD,
|
||||
'MIGRATE' => Token::FLAG_KEYWORD,
|
||||
'MIN_ROWS' => Token::FLAG_KEYWORD,
|
||||
'MODE' => Token::FLAG_KEYWORD,
|
||||
'MODIFY' => Token::FLAG_KEYWORD,
|
||||
'MUTEX' => Token::FLAG_KEYWORD,
|
||||
'NAME' => Token::FLAG_KEYWORD,
|
||||
'NAMES' => Token::FLAG_KEYWORD,
|
||||
'NATIONAL' => Token::FLAG_KEYWORD,
|
||||
'NCHAR' => Token::FLAG_KEYWORD,
|
||||
'NDB' => Token::FLAG_KEYWORD,
|
||||
'NDBCLUSTER' => Token::FLAG_KEYWORD,
|
||||
'NEW' => Token::FLAG_KEYWORD,
|
||||
'NEXT' => Token::FLAG_KEYWORD,
|
||||
'NO' => Token::FLAG_KEYWORD,
|
||||
'NONE' => Token::FLAG_KEYWORD,
|
||||
'NVARCHAR' => Token::FLAG_KEYWORD,
|
||||
'OFFSET' => Token::FLAG_KEYWORD,
|
||||
'ONE' => Token::FLAG_KEYWORD,
|
||||
'ONE_SHOT' => Token::FLAG_KEYWORD,
|
||||
'OPEN' => Token::FLAG_KEYWORD,
|
||||
'PACK_KEYS' => Token::FLAG_KEYWORD,
|
||||
'PAGE' => Token::FLAG_KEYWORD,
|
||||
'PARTIAL' => Token::FLAG_KEYWORD,
|
||||
'PARTITIONS' => Token::FLAG_KEYWORD,
|
||||
'PERSISTENT' => Token::FLAG_KEYWORD,
|
||||
'PHASE' => Token::FLAG_KEYWORD,
|
||||
'PREPARE' => Token::FLAG_KEYWORD,
|
||||
'PREV' => Token::FLAG_KEYWORD,
|
||||
'PRIVILEGES' => Token::FLAG_KEYWORD,
|
||||
'PROCESSLIST' => Token::FLAG_KEYWORD,
|
||||
'PROFILE' => Token::FLAG_KEYWORD,
|
||||
'PROFILES' => Token::FLAG_KEYWORD,
|
||||
'QUERY' => Token::FLAG_KEYWORD,
|
||||
'QUICK' => Token::FLAG_KEYWORD,
|
||||
'RAID0' => Token::FLAG_KEYWORD,
|
||||
'RAID_CHUNKS' => Token::FLAG_KEYWORD,
|
||||
'RAID_CHUNKSIZE' => Token::FLAG_KEYWORD,
|
||||
'RAID_TYPE' => Token::FLAG_KEYWORD,
|
||||
'RECOVER' => Token::FLAG_KEYWORD,
|
||||
'REDUNDANT' => Token::FLAG_KEYWORD,
|
||||
'RELAY_LOG_FILE' => Token::FLAG_KEYWORD,
|
||||
'RELAY_LOG_POS' => Token::FLAG_KEYWORD,
|
||||
'RELAY_THREAD' => Token::FLAG_KEYWORD,
|
||||
'RELOAD' => Token::FLAG_KEYWORD,
|
||||
'REPAIR' => Token::FLAG_KEYWORD,
|
||||
'REPEATABLE' => Token::FLAG_KEYWORD,
|
||||
'REPLICATION' => Token::FLAG_KEYWORD,
|
||||
'RESET' => Token::FLAG_KEYWORD,
|
||||
'RESTORE' => Token::FLAG_KEYWORD,
|
||||
'RESUME' => Token::FLAG_KEYWORD,
|
||||
'RETURNS' => Token::FLAG_KEYWORD,
|
||||
'ROLLBACK' => Token::FLAG_KEYWORD,
|
||||
'ROLLUP' => Token::FLAG_KEYWORD,
|
||||
'ROUTINE' => Token::FLAG_KEYWORD,
|
||||
'ROW' => Token::FLAG_KEYWORD,
|
||||
'ROWS' => Token::FLAG_KEYWORD,
|
||||
'ROW_FORMAT' => Token::FLAG_KEYWORD,
|
||||
'RTREE' => Token::FLAG_KEYWORD,
|
||||
'SAVEPOINT' => Token::FLAG_KEYWORD,
|
||||
'SECURITY' => Token::FLAG_KEYWORD,
|
||||
'SERIALIZABLE' => Token::FLAG_KEYWORD,
|
||||
'SESSION' => Token::FLAG_KEYWORD,
|
||||
'SHARE' => Token::FLAG_KEYWORD,
|
||||
'SHUTDOWN' => Token::FLAG_KEYWORD,
|
||||
'SIGNED' => Token::FLAG_KEYWORD,
|
||||
'SIMPLE' => Token::FLAG_KEYWORD,
|
||||
'SLAVE' => Token::FLAG_KEYWORD,
|
||||
'SNAPSHOT' => Token::FLAG_KEYWORD,
|
||||
'SOME' => Token::FLAG_KEYWORD,
|
||||
'SOUNDS' => Token::FLAG_KEYWORD,
|
||||
'SOURCE' => Token::FLAG_KEYWORD,
|
||||
'SQL_BUFFER_RESULT' => Token::FLAG_KEYWORD,
|
||||
'SQL_CACHE' => Token::FLAG_KEYWORD,
|
||||
'SQL_NO_CACHE' => Token::FLAG_KEYWORD,
|
||||
'SQL_THREAD' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_DAY' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_FRAC_SECOND' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_HOUR' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_MINUTE' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_MONTH' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_QUARTER' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_SECOND' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_WEEK' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_YEAR' => Token::FLAG_KEYWORD,
|
||||
'START' => Token::FLAG_KEYWORD,
|
||||
'STATUS' => Token::FLAG_KEYWORD,
|
||||
'STOP' => Token::FLAG_KEYWORD,
|
||||
'STORAGE' => Token::FLAG_KEYWORD,
|
||||
'STRING' => Token::FLAG_KEYWORD,
|
||||
'STRIPED' => Token::FLAG_KEYWORD,
|
||||
'SUBJECT' => Token::FLAG_KEYWORD,
|
||||
'SUBPARTITIONS' => Token::FLAG_KEYWORD,
|
||||
'SUPER' => Token::FLAG_KEYWORD,
|
||||
'SUSPEND' => Token::FLAG_KEYWORD,
|
||||
'SWAPS' => Token::FLAG_KEYWORD,
|
||||
'SWITCHES' => Token::FLAG_KEYWORD,
|
||||
'TABLES' => Token::FLAG_KEYWORD,
|
||||
'TABLESPACE' => Token::FLAG_KEYWORD,
|
||||
'TEMPORARY' => Token::FLAG_KEYWORD,
|
||||
'TEMPTABLE' => Token::FLAG_KEYWORD,
|
||||
'TRANSACTION' => Token::FLAG_KEYWORD,
|
||||
'TRIGGERS' => Token::FLAG_KEYWORD,
|
||||
'TYPE' => Token::FLAG_KEYWORD,
|
||||
'TYPES' => Token::FLAG_KEYWORD,
|
||||
'UNCOMMITTED' => Token::FLAG_KEYWORD,
|
||||
'UNDEFINED' => Token::FLAG_KEYWORD,
|
||||
'UNICODE' => Token::FLAG_KEYWORD,
|
||||
'UNKNOWN' => Token::FLAG_KEYWORD,
|
||||
'UNTIL' => Token::FLAG_KEYWORD,
|
||||
'UPGRADE' => Token::FLAG_KEYWORD,
|
||||
'USER_RESOURCES' => Token::FLAG_KEYWORD,
|
||||
'USE_FRM' => Token::FLAG_KEYWORD,
|
||||
'VALUE' => Token::FLAG_KEYWORD,
|
||||
'VARIABLES' => Token::FLAG_KEYWORD,
|
||||
'VIEW' => Token::FLAG_KEYWORD,
|
||||
'VIRTUAL' => Token::FLAG_KEYWORD,
|
||||
'WARNINGS' => Token::FLAG_KEYWORD,
|
||||
'WORK' => Token::FLAG_KEYWORD,
|
||||
'X509' => Token::FLAG_KEYWORD,
|
||||
'XA' => Token::FLAG_KEYWORD,
|
||||
'ADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ALL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ALTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ANALYZE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'AND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'AS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ASC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ASENSITIVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BEFORE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BETWEEN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BOTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CALL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CASCADE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CHANGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CHECK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'COLLATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'COLUMN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CONDITION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CONSTRAINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CONTINUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CREATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CROSS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CURSOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DATABASES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_HOUR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_MINUTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DEC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DECLARE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DELAYED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DELETE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DESC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DESCRIBE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DETERMINISTIC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DISTINCT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DISTINCTROW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DIV' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DROP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DUAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'EACH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ELSE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ELSEIF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ENCLOSED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ESCAPED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'EXIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'EXPLAIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FALSE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FETCH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FORCE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FOREIGN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FROM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'GRANT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'GROUP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HAVING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HIGH_PRIORITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HOUR_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HOUR_MINUTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HOUR_SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'IGNORE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INFILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INNER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INOUT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INSENSITIVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INTO' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'IS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ITERATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'KEYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'KILL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LEADING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LEAVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LIKE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LIMIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LINES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOAD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOOP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOW_PRIORITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MINUTE_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MINUTE_SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MODIFIES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NATURAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NOT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NO_WRITE_TO_BINLOG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OPTIMIZE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OPTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OPTIONALLY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ORDER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OUT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OUTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OUTFILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PRECISION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PRIMARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PROCEDURE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PURGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'READ' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'READS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REFERENCES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REGEXP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RELEASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RENAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REQUIRE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RESTRICT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RETURN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REVOKE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RLIKE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SCHEMAS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SECOND_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SELECT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SENSITIVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SEPARATOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SHOW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SONAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SPECIFIC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQLEXCEPTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQLSTATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQLWARNING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL_BIG_RESULT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL_CALC_FOUND_ROWS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL_SMALL_RESULT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SSL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'STARTING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'STRAIGHT_JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TABLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TERMINATED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'THEN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TO' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TRAILING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TRIGGER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TRUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNDO' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNLOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNSIGNED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UPDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'USAGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'USE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'USING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'VARCHARACTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'VARYING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WHEN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WHERE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WHILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WITH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WRITE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'XOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'YEAR_MONTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ZEROFILL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'AND CHAIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'AND NO CHAIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'CHARACTER SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'COALESCE PARTITION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'CONTAINS SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'CROSS JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DATA DIRECTORY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DEFAULT CHARACTER SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DEFAULT CHARSET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DEFAULT COLLATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ENCLOSED BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ESCAPED BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FOR EACH ROW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FOR UPDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FULL JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FULL OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'GENERATED ALWAYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'GROUP BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'IF EXISTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'IF NOT EXISTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'INDEX DIRECTORY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'INNER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LANGUAGE SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LEFT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LEFT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LESS THAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LINEAR HASH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LINEAR KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LOAD DATA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LOCK IN SHARE MODE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'MODIFIES SQL DATA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL LEFT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL LEFT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL RIGHT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL RIGHT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NO ACTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NO RELEASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NO SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NOT NULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON DELETE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON UPDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'OR REPLACE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ORDER BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'PARTITION BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'READS SQL DATA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'RIGHT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'RIGHT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SELECT TRANSACTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SET NULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SET PASSWORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SQL SECURITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'START TRANSACTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'STARTING BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SUBPARTITION BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'TERMINATED BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'UNION ALL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'UNION DISTINCT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'WITH CONSISTENT SNAPSHOT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'WITH ROLLUP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ARRAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BOOL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BOOLEAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'DATETIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'ENUM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FIXED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'GEOMETRY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'JSON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MULTILINEPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MULTILINEPOLYGON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MULTISET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'SERIAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'XML' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BIGINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'CHARACTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'DECIMAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'DOUBLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FLOAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FLOAT4' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FLOAT8' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT1' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT3' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT4' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT8' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INTEGER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONGBLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONGTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MEDIUMBLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MEDIUMINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MEDIUMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MIDDLEINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'NUMERIC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'REAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'SMALLINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TINYBLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TINYINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TINYTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'VARBINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'VARCHAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BINARY VARYING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'CHARACTER VARYING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONG VARBINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONG VARCHAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FULLTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'SPATIAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'UNIQUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'FOREIGN KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'FULLTEXT INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'FULLTEXT KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'INDEX KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'PRIMARY KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'SPATIAL INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'SPATIAL KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'UNIQUE INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'UNIQUE KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'ABS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ACOS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ADDDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ADDTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AES_DECRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AES_ENCRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AGAINST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AREA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASBINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASCII' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASWKT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ATAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ATAN2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AVG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BENCHMARK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_AND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_COUNT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_OR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_XOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CAST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CEIL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CEILING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CENTROID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHARACTER_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHARSET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHAR_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COALESCE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COERCIBILITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COLLATION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COMPRESS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONCAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONCAT_WS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONNECTION_ID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONTAINS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONV' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONVERT_TZ' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COUNT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CRC32' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CROSSES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATEDIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE_ADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE_FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE_SUB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYNAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYOFMONTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYOFWEEK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYOFYEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DECODE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DEGREES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DES_DECRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DES_ENCRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DIMENSION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DISJOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ELT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENCODE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENCRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENDPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENVELOPE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EQUALS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXPORT_SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXTERIORRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXTRACT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FIELD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FIND_IN_SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FLOOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FOUND_ROWS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FROM_DAYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FROM_UNIXTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMCOLLFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMCOLLFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYCOLLECTIONFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYCOLLECTIONFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYTYPE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GET_FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GET_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GLENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GREATEST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GROUP_CONCAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'HEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'HOUR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IFNULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INET_ATON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INET_NTOA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INSTR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INTERIORRINGN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INTERSECTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISCLOSED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISEMPTY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISNULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISSIMPLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IS_FREE_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IS_USED_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LAST_DAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LAST_INSERT_ID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LCASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LEAST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINEFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINEFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOAD_FILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOCATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOG10' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOG2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOWER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LPAD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LTRIM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAKEDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAKETIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAKE_SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MASTER_POS_WAIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRCONTAINS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRDISJOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBREQUAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRINTERSECTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBROVERLAPS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRTOUCHES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRWITHIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MD5' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MINUTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MLINEFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MLINEFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MONTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MONTHNAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOINTFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOINTFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOLYFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOLYFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NAME_CONST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NOW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NULLIF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NUMGEOMETRIES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NUMINTERIORRINGS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NUMPOINTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OCT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OCTET_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OLD_PASSWORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OVERLAPS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PASSWORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PERIOD_ADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PERIOD_DIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PI' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINTFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINTFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINTN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POSITION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POWER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'QUARTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'QUOTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RADIANS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RAND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RELEASE_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'REVERSE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ROUND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ROW_COUNT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RPAD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RTRIM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SEC_TO_TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SESSION_USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SHA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SHA1' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SIGN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SLEEP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SOUNDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SPACE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SQRT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SRID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STARTPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STDDEV' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STDDEV_POP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STDDEV_SAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STRCMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STR_TO_DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBSTR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBSTRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBSTRING_INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SYSDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SYSTEM_USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMEDIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMESTAMPADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMESTAMPDIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIME_FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIME_TO_SEC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TOUCHES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TO_DAYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TRIM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TRUNCATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UCASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNCOMPRESS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNCOMPRESSED_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNHEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNIX_TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UPPER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UUID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VARIANCE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VAR_POP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VAR_SAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VERSION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WEEK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WEEKDAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WEEKOFYEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WITHIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'X' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'Y' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'YEARWEEK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONVERT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATABASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DEFAULT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXISTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INSERT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LEFT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOCALTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOCALTIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MATCH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MOD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'REPEAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'REPLACE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RIGHT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SCHEMA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UTC_DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UTC_TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UTC_TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VALUES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NOT IN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYCOLLECTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINESTRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTILINESTRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOLYGON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYGON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'YEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INTERVAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
];
|
||||
}
|
||||
+904
@@ -0,0 +1,904 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Contexts;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
|
||||
/**
|
||||
* Context for MySQL 5.1.
|
||||
*
|
||||
* This class was auto-generated from tools/contexts/*.txt.
|
||||
* Use tools/run_generators.sh for update.
|
||||
*
|
||||
* @see https://dev.mysql.com/doc/refman/5.1/en/keywords.html
|
||||
*/
|
||||
class ContextMySql50100 extends Context
|
||||
{
|
||||
/**
|
||||
* List of keywords.
|
||||
*
|
||||
* The value associated to each keyword represents its flags.
|
||||
*
|
||||
* @see Token
|
||||
*
|
||||
* @var array<string,int>
|
||||
* @phpstan-var non-empty-array<non-empty-string,Token::FLAG_KEYWORD_*|int>
|
||||
*/
|
||||
public static $KEYWORDS = [
|
||||
'ACTION' => Token::FLAG_KEYWORD,
|
||||
'AFTER' => Token::FLAG_KEYWORD,
|
||||
'AGGREGATE' => Token::FLAG_KEYWORD,
|
||||
'ALGORITHM' => Token::FLAG_KEYWORD,
|
||||
'ANY' => Token::FLAG_KEYWORD,
|
||||
'AT' => Token::FLAG_KEYWORD,
|
||||
'AUTHORS' => Token::FLAG_KEYWORD,
|
||||
'AUTOEXTEND_SIZE' => Token::FLAG_KEYWORD,
|
||||
'AUTO_INCREMENT' => Token::FLAG_KEYWORD,
|
||||
'AVG_ROW_LENGTH' => Token::FLAG_KEYWORD,
|
||||
'BACKUP' => Token::FLAG_KEYWORD,
|
||||
'BDB' => Token::FLAG_KEYWORD,
|
||||
'BEGIN' => Token::FLAG_KEYWORD,
|
||||
'BERKELEYDB' => Token::FLAG_KEYWORD,
|
||||
'BINLOG' => Token::FLAG_KEYWORD,
|
||||
'BLOCK' => Token::FLAG_KEYWORD,
|
||||
'BTREE' => Token::FLAG_KEYWORD,
|
||||
'BYTE' => Token::FLAG_KEYWORD,
|
||||
'CACHE' => Token::FLAG_KEYWORD,
|
||||
'CASCADED' => Token::FLAG_KEYWORD,
|
||||
'CHAIN' => Token::FLAG_KEYWORD,
|
||||
'CHANGED' => Token::FLAG_KEYWORD,
|
||||
'CHECKSUM' => Token::FLAG_KEYWORD,
|
||||
'CIPHER' => Token::FLAG_KEYWORD,
|
||||
'CLIENT' => Token::FLAG_KEYWORD,
|
||||
'CLOSE' => Token::FLAG_KEYWORD,
|
||||
'CODE' => Token::FLAG_KEYWORD,
|
||||
'COLUMNS' => Token::FLAG_KEYWORD,
|
||||
'COMMENT' => Token::FLAG_KEYWORD,
|
||||
'COMMIT' => Token::FLAG_KEYWORD,
|
||||
'COMMITTED' => Token::FLAG_KEYWORD,
|
||||
'COMPACT' => Token::FLAG_KEYWORD,
|
||||
'COMPLETION' => Token::FLAG_KEYWORD,
|
||||
'COMPRESSED' => Token::FLAG_KEYWORD,
|
||||
'CONCURRENT' => Token::FLAG_KEYWORD,
|
||||
'CONNECTION' => Token::FLAG_KEYWORD,
|
||||
'CONSISTENT' => Token::FLAG_KEYWORD,
|
||||
'CONTEXT' => Token::FLAG_KEYWORD,
|
||||
'CONTRIBUTORS' => Token::FLAG_KEYWORD,
|
||||
'CPU' => Token::FLAG_KEYWORD,
|
||||
'CUBE' => Token::FLAG_KEYWORD,
|
||||
'DATA' => Token::FLAG_KEYWORD,
|
||||
'DATAFILE' => Token::FLAG_KEYWORD,
|
||||
'DEALLOCATE' => Token::FLAG_KEYWORD,
|
||||
'DEFINER' => Token::FLAG_KEYWORD,
|
||||
'DELAY_KEY_WRITE' => Token::FLAG_KEYWORD,
|
||||
'DES_KEY_FILE' => Token::FLAG_KEYWORD,
|
||||
'DIRECTORY' => Token::FLAG_KEYWORD,
|
||||
'DISABLE' => Token::FLAG_KEYWORD,
|
||||
'DISCARD' => Token::FLAG_KEYWORD,
|
||||
'DISK' => Token::FLAG_KEYWORD,
|
||||
'DO' => Token::FLAG_KEYWORD,
|
||||
'DUMPFILE' => Token::FLAG_KEYWORD,
|
||||
'DUPLICATE' => Token::FLAG_KEYWORD,
|
||||
'DYNAMIC' => Token::FLAG_KEYWORD,
|
||||
'ENABLE' => Token::FLAG_KEYWORD,
|
||||
'END' => Token::FLAG_KEYWORD,
|
||||
'ENDS' => Token::FLAG_KEYWORD,
|
||||
'ENGINE' => Token::FLAG_KEYWORD,
|
||||
'ENGINES' => Token::FLAG_KEYWORD,
|
||||
'ERRORS' => Token::FLAG_KEYWORD,
|
||||
'ESCAPE' => Token::FLAG_KEYWORD,
|
||||
'EVENT' => Token::FLAG_KEYWORD,
|
||||
'EVENTS' => Token::FLAG_KEYWORD,
|
||||
'EVERY' => Token::FLAG_KEYWORD,
|
||||
'EXECUTE' => Token::FLAG_KEYWORD,
|
||||
'EXPANSION' => Token::FLAG_KEYWORD,
|
||||
'EXTENDED' => Token::FLAG_KEYWORD,
|
||||
'EXTENT_SIZE' => Token::FLAG_KEYWORD,
|
||||
'FAST' => Token::FLAG_KEYWORD,
|
||||
'FAULTS' => Token::FLAG_KEYWORD,
|
||||
'FIELDS' => Token::FLAG_KEYWORD,
|
||||
'FILE' => Token::FLAG_KEYWORD,
|
||||
'FIRST' => Token::FLAG_KEYWORD,
|
||||
'FLUSH' => Token::FLAG_KEYWORD,
|
||||
'FOUND' => Token::FLAG_KEYWORD,
|
||||
'FRAC_SECOND' => Token::FLAG_KEYWORD,
|
||||
'FULL' => Token::FLAG_KEYWORD,
|
||||
'FUNCTION' => Token::FLAG_KEYWORD,
|
||||
'GLOBAL' => Token::FLAG_KEYWORD,
|
||||
'GOTO' => Token::FLAG_KEYWORD,
|
||||
'GRANTS' => Token::FLAG_KEYWORD,
|
||||
'HANDLER' => Token::FLAG_KEYWORD,
|
||||
'HASH' => Token::FLAG_KEYWORD,
|
||||
'HELP' => Token::FLAG_KEYWORD,
|
||||
'HOST' => Token::FLAG_KEYWORD,
|
||||
'HOSTS' => Token::FLAG_KEYWORD,
|
||||
'IDENTIFIED' => Token::FLAG_KEYWORD,
|
||||
'IMPORT' => Token::FLAG_KEYWORD,
|
||||
'INDEXES' => Token::FLAG_KEYWORD,
|
||||
'INITIAL_SIZE' => Token::FLAG_KEYWORD,
|
||||
'INNOBASE' => Token::FLAG_KEYWORD,
|
||||
'INNODB' => Token::FLAG_KEYWORD,
|
||||
'INSERT_METHOD' => Token::FLAG_KEYWORD,
|
||||
'INSTALL' => Token::FLAG_KEYWORD,
|
||||
'INVOKER' => Token::FLAG_KEYWORD,
|
||||
'IO' => Token::FLAG_KEYWORD,
|
||||
'IO_THREAD' => Token::FLAG_KEYWORD,
|
||||
'IPC' => Token::FLAG_KEYWORD,
|
||||
'ISOLATION' => Token::FLAG_KEYWORD,
|
||||
'ISSUER' => Token::FLAG_KEYWORD,
|
||||
'KEY_BLOCK_SIZE' => Token::FLAG_KEYWORD,
|
||||
'LABEL' => Token::FLAG_KEYWORD,
|
||||
'LANGUAGE' => Token::FLAG_KEYWORD,
|
||||
'LAST' => Token::FLAG_KEYWORD,
|
||||
'LEAVES' => Token::FLAG_KEYWORD,
|
||||
'LESS' => Token::FLAG_KEYWORD,
|
||||
'LEVEL' => Token::FLAG_KEYWORD,
|
||||
'LIST' => Token::FLAG_KEYWORD,
|
||||
'LOCAL' => Token::FLAG_KEYWORD,
|
||||
'LOCKS' => Token::FLAG_KEYWORD,
|
||||
'LOGFILE' => Token::FLAG_KEYWORD,
|
||||
'LOGS' => Token::FLAG_KEYWORD,
|
||||
'MASTER' => Token::FLAG_KEYWORD,
|
||||
'MASTER_CONNECT_RETRY' => Token::FLAG_KEYWORD,
|
||||
'MASTER_HOST' => Token::FLAG_KEYWORD,
|
||||
'MASTER_LOG_FILE' => Token::FLAG_KEYWORD,
|
||||
'MASTER_LOG_POS' => Token::FLAG_KEYWORD,
|
||||
'MASTER_PASSWORD' => Token::FLAG_KEYWORD,
|
||||
'MASTER_PORT' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SERVER_ID' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CA' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CAPATH' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CERT' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CIPHER' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_KEY' => Token::FLAG_KEYWORD,
|
||||
'MASTER_USER' => Token::FLAG_KEYWORD,
|
||||
'MAXVALUE' => Token::FLAG_KEYWORD,
|
||||
'MAX_CONNECTIONS_PER_HOUR' => Token::FLAG_KEYWORD,
|
||||
'MAX_QUERIES_PER_HOUR' => Token::FLAG_KEYWORD,
|
||||
'MAX_ROWS' => Token::FLAG_KEYWORD,
|
||||
'MAX_SIZE' => Token::FLAG_KEYWORD,
|
||||
'MAX_UPDATES_PER_HOUR' => Token::FLAG_KEYWORD,
|
||||
'MAX_USER_CONNECTIONS' => Token::FLAG_KEYWORD,
|
||||
'MEDIUM' => Token::FLAG_KEYWORD,
|
||||
'MEMORY' => Token::FLAG_KEYWORD,
|
||||
'MERGE' => Token::FLAG_KEYWORD,
|
||||
'MIGRATE' => Token::FLAG_KEYWORD,
|
||||
'MIN_ROWS' => Token::FLAG_KEYWORD,
|
||||
'MODE' => Token::FLAG_KEYWORD,
|
||||
'MODIFY' => Token::FLAG_KEYWORD,
|
||||
'MUTEX' => Token::FLAG_KEYWORD,
|
||||
'NAME' => Token::FLAG_KEYWORD,
|
||||
'NAMES' => Token::FLAG_KEYWORD,
|
||||
'NATIONAL' => Token::FLAG_KEYWORD,
|
||||
'NCHAR' => Token::FLAG_KEYWORD,
|
||||
'NDB' => Token::FLAG_KEYWORD,
|
||||
'NDBCLUSTER' => Token::FLAG_KEYWORD,
|
||||
'NEW' => Token::FLAG_KEYWORD,
|
||||
'NEXT' => Token::FLAG_KEYWORD,
|
||||
'NO' => Token::FLAG_KEYWORD,
|
||||
'NODEGROUP' => Token::FLAG_KEYWORD,
|
||||
'NONE' => Token::FLAG_KEYWORD,
|
||||
'NO_WAIT' => Token::FLAG_KEYWORD,
|
||||
'NVARCHAR' => Token::FLAG_KEYWORD,
|
||||
'OFFSET' => Token::FLAG_KEYWORD,
|
||||
'ONE' => Token::FLAG_KEYWORD,
|
||||
'ONE_SHOT' => Token::FLAG_KEYWORD,
|
||||
'OPEN' => Token::FLAG_KEYWORD,
|
||||
'OPTIONS' => Token::FLAG_KEYWORD,
|
||||
'OWNER' => Token::FLAG_KEYWORD,
|
||||
'PACK_KEYS' => Token::FLAG_KEYWORD,
|
||||
'PAGE' => Token::FLAG_KEYWORD,
|
||||
'PAGE_CHECKSUM' => Token::FLAG_KEYWORD,
|
||||
'PARSER' => Token::FLAG_KEYWORD,
|
||||
'PARTIAL' => Token::FLAG_KEYWORD,
|
||||
'PARTITION' => Token::FLAG_KEYWORD,
|
||||
'PARTITIONING' => Token::FLAG_KEYWORD,
|
||||
'PARTITIONS' => Token::FLAG_KEYWORD,
|
||||
'PERSISTENT' => Token::FLAG_KEYWORD,
|
||||
'PHASE' => Token::FLAG_KEYWORD,
|
||||
'PLUGIN' => Token::FLAG_KEYWORD,
|
||||
'PLUGINS' => Token::FLAG_KEYWORD,
|
||||
'PORT' => Token::FLAG_KEYWORD,
|
||||
'PREPARE' => Token::FLAG_KEYWORD,
|
||||
'PRESERVE' => Token::FLAG_KEYWORD,
|
||||
'PREV' => Token::FLAG_KEYWORD,
|
||||
'PRIVILEGES' => Token::FLAG_KEYWORD,
|
||||
'PROCESSLIST' => Token::FLAG_KEYWORD,
|
||||
'PROFILE' => Token::FLAG_KEYWORD,
|
||||
'PROFILES' => Token::FLAG_KEYWORD,
|
||||
'QUERY' => Token::FLAG_KEYWORD,
|
||||
'QUICK' => Token::FLAG_KEYWORD,
|
||||
'RAID0' => Token::FLAG_KEYWORD,
|
||||
'RAID_CHUNKS' => Token::FLAG_KEYWORD,
|
||||
'RAID_CHUNKSIZE' => Token::FLAG_KEYWORD,
|
||||
'RAID_TYPE' => Token::FLAG_KEYWORD,
|
||||
'READ_ONLY' => Token::FLAG_KEYWORD,
|
||||
'REBUILD' => Token::FLAG_KEYWORD,
|
||||
'RECOVER' => Token::FLAG_KEYWORD,
|
||||
'REDOFILE' => Token::FLAG_KEYWORD,
|
||||
'REDO_BUFFER_SIZE' => Token::FLAG_KEYWORD,
|
||||
'REDUNDANT' => Token::FLAG_KEYWORD,
|
||||
'RELAY_LOG_FILE' => Token::FLAG_KEYWORD,
|
||||
'RELAY_LOG_POS' => Token::FLAG_KEYWORD,
|
||||
'RELAY_THREAD' => Token::FLAG_KEYWORD,
|
||||
'RELOAD' => Token::FLAG_KEYWORD,
|
||||
'REMOVE' => Token::FLAG_KEYWORD,
|
||||
'REORGANISE' => Token::FLAG_KEYWORD,
|
||||
'REORGANIZE' => Token::FLAG_KEYWORD,
|
||||
'REPAIR' => Token::FLAG_KEYWORD,
|
||||
'REPEATABLE' => Token::FLAG_KEYWORD,
|
||||
'REPLICATION' => Token::FLAG_KEYWORD,
|
||||
'RESET' => Token::FLAG_KEYWORD,
|
||||
'RESTORE' => Token::FLAG_KEYWORD,
|
||||
'RESUME' => Token::FLAG_KEYWORD,
|
||||
'RETURNS' => Token::FLAG_KEYWORD,
|
||||
'ROLLBACK' => Token::FLAG_KEYWORD,
|
||||
'ROLLUP' => Token::FLAG_KEYWORD,
|
||||
'ROUTINE' => Token::FLAG_KEYWORD,
|
||||
'ROW' => Token::FLAG_KEYWORD,
|
||||
'ROWS' => Token::FLAG_KEYWORD,
|
||||
'ROW_FORMAT' => Token::FLAG_KEYWORD,
|
||||
'RTREE' => Token::FLAG_KEYWORD,
|
||||
'SAVEPOINT' => Token::FLAG_KEYWORD,
|
||||
'SCHEDULE' => Token::FLAG_KEYWORD,
|
||||
'SCHEDULER' => Token::FLAG_KEYWORD,
|
||||
'SECURITY' => Token::FLAG_KEYWORD,
|
||||
'SERIALIZABLE' => Token::FLAG_KEYWORD,
|
||||
'SERVER' => Token::FLAG_KEYWORD,
|
||||
'SESSION' => Token::FLAG_KEYWORD,
|
||||
'SHARE' => Token::FLAG_KEYWORD,
|
||||
'SHUTDOWN' => Token::FLAG_KEYWORD,
|
||||
'SIGNED' => Token::FLAG_KEYWORD,
|
||||
'SIMPLE' => Token::FLAG_KEYWORD,
|
||||
'SLAVE' => Token::FLAG_KEYWORD,
|
||||
'SNAPSHOT' => Token::FLAG_KEYWORD,
|
||||
'SOCKET' => Token::FLAG_KEYWORD,
|
||||
'SOME' => Token::FLAG_KEYWORD,
|
||||
'SONAME' => Token::FLAG_KEYWORD,
|
||||
'SOUNDS' => Token::FLAG_KEYWORD,
|
||||
'SOURCE' => Token::FLAG_KEYWORD,
|
||||
'SQL_BUFFER_RESULT' => Token::FLAG_KEYWORD,
|
||||
'SQL_CACHE' => Token::FLAG_KEYWORD,
|
||||
'SQL_NO_CACHE' => Token::FLAG_KEYWORD,
|
||||
'SQL_THREAD' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_DAY' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_FRAC_SECOND' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_HOUR' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_MINUTE' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_MONTH' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_QUARTER' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_SECOND' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_WEEK' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_YEAR' => Token::FLAG_KEYWORD,
|
||||
'START' => Token::FLAG_KEYWORD,
|
||||
'STARTS' => Token::FLAG_KEYWORD,
|
||||
'STATUS' => Token::FLAG_KEYWORD,
|
||||
'STOP' => Token::FLAG_KEYWORD,
|
||||
'STORAGE' => Token::FLAG_KEYWORD,
|
||||
'STRING' => Token::FLAG_KEYWORD,
|
||||
'STRIPED' => Token::FLAG_KEYWORD,
|
||||
'SUBJECT' => Token::FLAG_KEYWORD,
|
||||
'SUBPARTITION' => Token::FLAG_KEYWORD,
|
||||
'SUBPARTITIONS' => Token::FLAG_KEYWORD,
|
||||
'SUPER' => Token::FLAG_KEYWORD,
|
||||
'SUSPEND' => Token::FLAG_KEYWORD,
|
||||
'SWAPS' => Token::FLAG_KEYWORD,
|
||||
'SWITCHES' => Token::FLAG_KEYWORD,
|
||||
'TABLES' => Token::FLAG_KEYWORD,
|
||||
'TABLESPACE' => Token::FLAG_KEYWORD,
|
||||
'TABLE_CHECKSUM' => Token::FLAG_KEYWORD,
|
||||
'TEMPORARY' => Token::FLAG_KEYWORD,
|
||||
'TEMPTABLE' => Token::FLAG_KEYWORD,
|
||||
'THAN' => Token::FLAG_KEYWORD,
|
||||
'TRANSACTION' => Token::FLAG_KEYWORD,
|
||||
'TRANSACTIONAL' => Token::FLAG_KEYWORD,
|
||||
'TRIGGERS' => Token::FLAG_KEYWORD,
|
||||
'TYPE' => Token::FLAG_KEYWORD,
|
||||
'TYPES' => Token::FLAG_KEYWORD,
|
||||
'UNCOMMITTED' => Token::FLAG_KEYWORD,
|
||||
'UNDEFINED' => Token::FLAG_KEYWORD,
|
||||
'UNDOFILE' => Token::FLAG_KEYWORD,
|
||||
'UNDO_BUFFER_SIZE' => Token::FLAG_KEYWORD,
|
||||
'UNICODE' => Token::FLAG_KEYWORD,
|
||||
'UNINSTALL' => Token::FLAG_KEYWORD,
|
||||
'UNKNOWN' => Token::FLAG_KEYWORD,
|
||||
'UNTIL' => Token::FLAG_KEYWORD,
|
||||
'UPGRADE' => Token::FLAG_KEYWORD,
|
||||
'USER_RESOURCES' => Token::FLAG_KEYWORD,
|
||||
'USE_FRM' => Token::FLAG_KEYWORD,
|
||||
'VALUE' => Token::FLAG_KEYWORD,
|
||||
'VARIABLES' => Token::FLAG_KEYWORD,
|
||||
'VIEW' => Token::FLAG_KEYWORD,
|
||||
'VIRTUAL' => Token::FLAG_KEYWORD,
|
||||
'WAIT' => Token::FLAG_KEYWORD,
|
||||
'WARNINGS' => Token::FLAG_KEYWORD,
|
||||
'WORK' => Token::FLAG_KEYWORD,
|
||||
'WRAPPER' => Token::FLAG_KEYWORD,
|
||||
'X509' => Token::FLAG_KEYWORD,
|
||||
'XA' => Token::FLAG_KEYWORD,
|
||||
'ACCESSIBLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ALL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ALTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ANALYZE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'AND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'AS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ASC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ASENSITIVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BEFORE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BETWEEN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BOTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CALL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CASCADE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CHANGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CHECK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'COLLATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'COLUMN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CONDITION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CONSTRAINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CONTINUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CREATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CROSS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CURSOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DATABASES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_HOUR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_MINUTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DEC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DECLARE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DELAYED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DELETE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DESC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DESCRIBE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DETERMINISTIC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DISTINCT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DISTINCTROW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DIV' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DROP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DUAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'EACH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ELSE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ELSEIF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ENCLOSED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ESCAPED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'EXIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'EXPLAIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FALSE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FETCH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FORCE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FOREIGN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FROM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'GRANT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'GROUP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HAVING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HIGH_PRIORITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HOUR_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HOUR_MINUTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HOUR_SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'IGNORE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INFILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INNER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INOUT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INSENSITIVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INTO' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'IS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ITERATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'KEYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'KILL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LEADING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LEAVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LIKE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LIMIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LINEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LINES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOAD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOOP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOW_PRIORITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MASTER_SSL_VERIFY_SERVER_CERT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MINUTE_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MINUTE_SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MODIFIES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NATURAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NOT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NO_WRITE_TO_BINLOG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OPTIMIZE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OPTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OPTIONALLY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ORDER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OUT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OUTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OUTFILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PRECISION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PRIMARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PROCEDURE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PURGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RANGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'READ' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'READS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'READ_WRITE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REFERENCES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REGEXP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RELEASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RENAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REQUIRE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RESTRICT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RETURN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REVOKE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RLIKE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SCHEMAS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SECOND_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SELECT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SENSITIVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SEPARATOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SHOW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SPECIFIC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQLEXCEPTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQLSTATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQLWARNING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL_BIG_RESULT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL_CALC_FOUND_ROWS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL_SMALL_RESULT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SSL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'STARTING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'STRAIGHT_JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TABLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TERMINATED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'THEN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TO' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TRAILING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TRIGGER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TRUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNDO' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNLOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNSIGNED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UPDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'USAGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'USE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'USING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'VARCHARACTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'VARYING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WHEN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WHERE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WHILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WITH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WRITE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'XOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'YEAR_MONTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ZEROFILL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'AND CHAIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'AND NO CHAIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'CHARACTER SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'COALESCE PARTITION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'CONTAINS SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'CROSS JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DATA DIRECTORY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DEFAULT CHARACTER SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DEFAULT CHARSET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DEFAULT COLLATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DISABLE ON SLAVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ENCLOSED BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ESCAPED BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FOR EACH ROW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FOR UPDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FULL JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FULL OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'GENERATED ALWAYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'GROUP BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'IF EXISTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'IF NOT EXISTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'INDEX DIRECTORY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'INNER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LANGUAGE SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LEFT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LEFT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LESS THAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LINEAR HASH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LINEAR KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LOAD DATA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LOCK IN SHARE MODE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'MODIFIES SQL DATA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL LEFT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL LEFT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL RIGHT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL RIGHT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NO ACTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NO RELEASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NO SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NOT NULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON COMPLETION NOT PRESERVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON COMPLETION PRESERVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON DELETE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON SCHEDULE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON UPDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'OR REPLACE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ORDER BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'PARTITION BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'READS SQL DATA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'RIGHT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'RIGHT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SELECT TRANSACTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SET NULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SET PASSWORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SQL SECURITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'START TRANSACTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'STARTING BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SUBPARTITION BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'TERMINATED BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'UNION ALL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'UNION DISTINCT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'WITH CONSISTENT SNAPSHOT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'WITH PARSER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'WITH ROLLUP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ARRAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BOOL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BOOLEAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'DATETIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'ENUM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FIXED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'GEOMETRY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'JSON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MULTILINEPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MULTILINEPOLYGON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MULTISET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'SERIAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'XML' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BIGINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'CHARACTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'DECIMAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'DOUBLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FLOAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FLOAT4' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FLOAT8' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT1' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT3' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT4' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT8' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INTEGER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONGBLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONGTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MEDIUMBLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MEDIUMINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MEDIUMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MIDDLEINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'NUMERIC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'REAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'SMALLINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TINYBLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TINYINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TINYTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'VARBINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'VARCHAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BINARY VARYING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'CHARACTER VARYING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONG VARBINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONG VARCHAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FULLTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'SPATIAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'UNIQUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'FOREIGN KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'FULLTEXT INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'FULLTEXT KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'INDEX KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'PRIMARY KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'SPATIAL INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'SPATIAL KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'UNIQUE INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'UNIQUE KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'ABS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ACOS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ADDDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ADDTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AES_DECRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AES_ENCRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AGAINST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AREA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASBINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASCII' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASWKT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ATAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ATAN2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AVG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BENCHMARK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_AND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_COUNT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_OR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_XOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CAST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CEIL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CEILING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CENTROID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHARACTER_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHARSET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHAR_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COALESCE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COERCIBILITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COLLATION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COMPRESS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONCAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONCAT_WS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONNECTION_ID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONTAINS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONV' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONVERT_TZ' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COUNT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CRC32' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CROSSES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATEDIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE_ADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE_FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE_SUB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYNAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYOFMONTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYOFWEEK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYOFYEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DECODE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DEGREES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DES_DECRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DES_ENCRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DIMENSION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DISJOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ELT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENCODE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENCRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENDPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENVELOPE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EQUALS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXPORT_SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXTERIORRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXTRACT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXTRACTVALUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FIELD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FIND_IN_SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FLOOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FOUND_ROWS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FROM_DAYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FROM_UNIXTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMCOLLFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMCOLLFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYCOLLECTIONFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYCOLLECTIONFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYTYPE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GET_FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GET_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GLENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GREATEST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GROUP_CONCAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'HEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'HOUR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IFNULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INET_ATON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INET_NTOA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INSTR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INTERIORRINGN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INTERSECTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISCLOSED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISEMPTY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISNULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISSIMPLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IS_FREE_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IS_USED_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LAST_DAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LAST_INSERT_ID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LCASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LEAST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINEFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINEFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINESTRINGFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINESTRINGFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOAD_FILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOCATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOG10' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOG2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOWER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LPAD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LTRIM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAKEDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAKETIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAKE_SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MASTER_POS_WAIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRCONTAINS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRDISJOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBREQUAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRINTERSECTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBROVERLAPS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRTOUCHES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRWITHIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MD5' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MINUTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MLINEFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MLINEFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MONTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MONTHNAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOINTFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOINTFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOLYFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOLYFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTILINESTRINGFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTILINESTRINGFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOINTFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOINTFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOLYGONFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOLYGONFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NAME_CONST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NOW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NULLIF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NUMGEOMETRIES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NUMINTERIORRINGS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NUMPOINTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OCT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OCTET_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OLD_PASSWORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OVERLAPS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PASSWORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PERIOD_ADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PERIOD_DIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PI' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINTFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINTFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINTN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYGONFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYGONFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POSITION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POWER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'QUARTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'QUOTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RADIANS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RAND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RELEASE_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'REVERSE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ROUND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ROW_COUNT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RPAD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RTRIM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SEC_TO_TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SESSION_USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SHA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SHA1' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SIGN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SLEEP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SOUNDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SPACE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SQRT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SRID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STARTPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STDDEV' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STDDEV_POP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STDDEV_SAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STRCMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STR_TO_DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBSTR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBSTRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBSTRING_INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SYSDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SYSTEM_USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMEDIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMESTAMPADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMESTAMPDIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIME_FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIME_TO_SEC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TOUCHES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TO_DAYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TRIM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TRUNCATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UCASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNCOMPRESS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNCOMPRESSED_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNHEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNIX_TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UPDATEXML' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UPPER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UUID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UUID_SHORT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VARIANCE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VAR_POP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VAR_SAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VERSION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WEEK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WEEKDAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WEEKOFYEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WITHIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'X' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'Y' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'YEARWEEK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONVERT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATABASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DEFAULT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXISTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INSERT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LEFT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOCALTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOCALTIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MATCH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MOD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'REPEAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'REPLACE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RIGHT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SCHEMA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UTC_DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UTC_TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UTC_TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VALUES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NOT IN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYCOLLECTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINESTRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTILINESTRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOLYGON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYGON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'YEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INTERVAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
];
|
||||
}
|
||||
+915
@@ -0,0 +1,915 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Contexts;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
|
||||
/**
|
||||
* Context for MySQL 5.5.
|
||||
*
|
||||
* This class was auto-generated from tools/contexts/*.txt.
|
||||
* Use tools/run_generators.sh for update.
|
||||
*
|
||||
* @see https://dev.mysql.com/doc/refman/5.5/en/keywords.html
|
||||
*/
|
||||
class ContextMySql50500 extends Context
|
||||
{
|
||||
/**
|
||||
* List of keywords.
|
||||
*
|
||||
* The value associated to each keyword represents its flags.
|
||||
*
|
||||
* @see Token
|
||||
*
|
||||
* @var array<string,int>
|
||||
* @phpstan-var non-empty-array<non-empty-string,Token::FLAG_KEYWORD_*|int>
|
||||
*/
|
||||
public static $KEYWORDS = [
|
||||
'ACTION' => Token::FLAG_KEYWORD,
|
||||
'AFTER' => Token::FLAG_KEYWORD,
|
||||
'AGGREGATE' => Token::FLAG_KEYWORD,
|
||||
'ALGORITHM' => Token::FLAG_KEYWORD,
|
||||
'ANY' => Token::FLAG_KEYWORD,
|
||||
'AT' => Token::FLAG_KEYWORD,
|
||||
'AUTHORS' => Token::FLAG_KEYWORD,
|
||||
'AUTOEXTEND_SIZE' => Token::FLAG_KEYWORD,
|
||||
'AUTO_INCREMENT' => Token::FLAG_KEYWORD,
|
||||
'AVG_ROW_LENGTH' => Token::FLAG_KEYWORD,
|
||||
'BACKUP' => Token::FLAG_KEYWORD,
|
||||
'BEGIN' => Token::FLAG_KEYWORD,
|
||||
'BINLOG' => Token::FLAG_KEYWORD,
|
||||
'BLOCK' => Token::FLAG_KEYWORD,
|
||||
'BTREE' => Token::FLAG_KEYWORD,
|
||||
'BYTE' => Token::FLAG_KEYWORD,
|
||||
'CACHE' => Token::FLAG_KEYWORD,
|
||||
'CASCADED' => Token::FLAG_KEYWORD,
|
||||
'CATALOG_NAME' => Token::FLAG_KEYWORD,
|
||||
'CHAIN' => Token::FLAG_KEYWORD,
|
||||
'CHANGED' => Token::FLAG_KEYWORD,
|
||||
'CHECKSUM' => Token::FLAG_KEYWORD,
|
||||
'CIPHER' => Token::FLAG_KEYWORD,
|
||||
'CLASS_ORIGIN' => Token::FLAG_KEYWORD,
|
||||
'CLIENT' => Token::FLAG_KEYWORD,
|
||||
'CLOSE' => Token::FLAG_KEYWORD,
|
||||
'CODE' => Token::FLAG_KEYWORD,
|
||||
'COLUMNS' => Token::FLAG_KEYWORD,
|
||||
'COLUMN_NAME' => Token::FLAG_KEYWORD,
|
||||
'COMMENT' => Token::FLAG_KEYWORD,
|
||||
'COMMIT' => Token::FLAG_KEYWORD,
|
||||
'COMMITTED' => Token::FLAG_KEYWORD,
|
||||
'COMPACT' => Token::FLAG_KEYWORD,
|
||||
'COMPLETION' => Token::FLAG_KEYWORD,
|
||||
'COMPRESSED' => Token::FLAG_KEYWORD,
|
||||
'CONCURRENT' => Token::FLAG_KEYWORD,
|
||||
'CONNECTION' => Token::FLAG_KEYWORD,
|
||||
'CONSISTENT' => Token::FLAG_KEYWORD,
|
||||
'CONSTRAINT_CATALOG' => Token::FLAG_KEYWORD,
|
||||
'CONSTRAINT_NAME' => Token::FLAG_KEYWORD,
|
||||
'CONSTRAINT_SCHEMA' => Token::FLAG_KEYWORD,
|
||||
'CONTEXT' => Token::FLAG_KEYWORD,
|
||||
'CONTRIBUTORS' => Token::FLAG_KEYWORD,
|
||||
'CPU' => Token::FLAG_KEYWORD,
|
||||
'CUBE' => Token::FLAG_KEYWORD,
|
||||
'CURSOR_NAME' => Token::FLAG_KEYWORD,
|
||||
'DATA' => Token::FLAG_KEYWORD,
|
||||
'DATAFILE' => Token::FLAG_KEYWORD,
|
||||
'DEALLOCATE' => Token::FLAG_KEYWORD,
|
||||
'DEFINER' => Token::FLAG_KEYWORD,
|
||||
'DELAY_KEY_WRITE' => Token::FLAG_KEYWORD,
|
||||
'DES_KEY_FILE' => Token::FLAG_KEYWORD,
|
||||
'DIRECTORY' => Token::FLAG_KEYWORD,
|
||||
'DISABLE' => Token::FLAG_KEYWORD,
|
||||
'DISCARD' => Token::FLAG_KEYWORD,
|
||||
'DISK' => Token::FLAG_KEYWORD,
|
||||
'DO' => Token::FLAG_KEYWORD,
|
||||
'DUMPFILE' => Token::FLAG_KEYWORD,
|
||||
'DUPLICATE' => Token::FLAG_KEYWORD,
|
||||
'DYNAMIC' => Token::FLAG_KEYWORD,
|
||||
'ENABLE' => Token::FLAG_KEYWORD,
|
||||
'END' => Token::FLAG_KEYWORD,
|
||||
'ENDS' => Token::FLAG_KEYWORD,
|
||||
'ENGINE' => Token::FLAG_KEYWORD,
|
||||
'ENGINES' => Token::FLAG_KEYWORD,
|
||||
'ERROR' => Token::FLAG_KEYWORD,
|
||||
'ERRORS' => Token::FLAG_KEYWORD,
|
||||
'ESCAPE' => Token::FLAG_KEYWORD,
|
||||
'EVENT' => Token::FLAG_KEYWORD,
|
||||
'EVENTS' => Token::FLAG_KEYWORD,
|
||||
'EVERY' => Token::FLAG_KEYWORD,
|
||||
'EXECUTE' => Token::FLAG_KEYWORD,
|
||||
'EXPANSION' => Token::FLAG_KEYWORD,
|
||||
'EXTENDED' => Token::FLAG_KEYWORD,
|
||||
'EXTENT_SIZE' => Token::FLAG_KEYWORD,
|
||||
'FAST' => Token::FLAG_KEYWORD,
|
||||
'FAULTS' => Token::FLAG_KEYWORD,
|
||||
'FIELDS' => Token::FLAG_KEYWORD,
|
||||
'FILE' => Token::FLAG_KEYWORD,
|
||||
'FIRST' => Token::FLAG_KEYWORD,
|
||||
'FLUSH' => Token::FLAG_KEYWORD,
|
||||
'FOUND' => Token::FLAG_KEYWORD,
|
||||
'FRAC_SECOND' => Token::FLAG_KEYWORD,
|
||||
'FULL' => Token::FLAG_KEYWORD,
|
||||
'FUNCTION' => Token::FLAG_KEYWORD,
|
||||
'GENERAL' => Token::FLAG_KEYWORD,
|
||||
'GLOBAL' => Token::FLAG_KEYWORD,
|
||||
'GRANTS' => Token::FLAG_KEYWORD,
|
||||
'HANDLER' => Token::FLAG_KEYWORD,
|
||||
'HASH' => Token::FLAG_KEYWORD,
|
||||
'HELP' => Token::FLAG_KEYWORD,
|
||||
'HOST' => Token::FLAG_KEYWORD,
|
||||
'HOSTS' => Token::FLAG_KEYWORD,
|
||||
'IDENTIFIED' => Token::FLAG_KEYWORD,
|
||||
'IGNORE_SERVER_IDS' => Token::FLAG_KEYWORD,
|
||||
'IMPORT' => Token::FLAG_KEYWORD,
|
||||
'INDEXES' => Token::FLAG_KEYWORD,
|
||||
'INITIAL_SIZE' => Token::FLAG_KEYWORD,
|
||||
'INNOBASE' => Token::FLAG_KEYWORD,
|
||||
'INNODB' => Token::FLAG_KEYWORD,
|
||||
'INSERT_METHOD' => Token::FLAG_KEYWORD,
|
||||
'INSTALL' => Token::FLAG_KEYWORD,
|
||||
'INVOKER' => Token::FLAG_KEYWORD,
|
||||
'IO' => Token::FLAG_KEYWORD,
|
||||
'IO_THREAD' => Token::FLAG_KEYWORD,
|
||||
'IPC' => Token::FLAG_KEYWORD,
|
||||
'ISOLATION' => Token::FLAG_KEYWORD,
|
||||
'ISSUER' => Token::FLAG_KEYWORD,
|
||||
'KEY_BLOCK_SIZE' => Token::FLAG_KEYWORD,
|
||||
'LANGUAGE' => Token::FLAG_KEYWORD,
|
||||
'LAST' => Token::FLAG_KEYWORD,
|
||||
'LEAVES' => Token::FLAG_KEYWORD,
|
||||
'LESS' => Token::FLAG_KEYWORD,
|
||||
'LEVEL' => Token::FLAG_KEYWORD,
|
||||
'LIST' => Token::FLAG_KEYWORD,
|
||||
'LOCAL' => Token::FLAG_KEYWORD,
|
||||
'LOCKS' => Token::FLAG_KEYWORD,
|
||||
'LOGFILE' => Token::FLAG_KEYWORD,
|
||||
'LOGS' => Token::FLAG_KEYWORD,
|
||||
'MASTER' => Token::FLAG_KEYWORD,
|
||||
'MASTER_CONNECT_RETRY' => Token::FLAG_KEYWORD,
|
||||
'MASTER_HEARTBEAT_PERIOD' => Token::FLAG_KEYWORD,
|
||||
'MASTER_HOST' => Token::FLAG_KEYWORD,
|
||||
'MASTER_LOG_FILE' => Token::FLAG_KEYWORD,
|
||||
'MASTER_LOG_POS' => Token::FLAG_KEYWORD,
|
||||
'MASTER_PASSWORD' => Token::FLAG_KEYWORD,
|
||||
'MASTER_PORT' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SERVER_ID' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CA' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CAPATH' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CERT' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_CIPHER' => Token::FLAG_KEYWORD,
|
||||
'MASTER_SSL_KEY' => Token::FLAG_KEYWORD,
|
||||
'MASTER_USER' => Token::FLAG_KEYWORD,
|
||||
'MAX_CONNECTIONS_PER_HOUR' => Token::FLAG_KEYWORD,
|
||||
'MAX_QUERIES_PER_HOUR' => Token::FLAG_KEYWORD,
|
||||
'MAX_ROWS' => Token::FLAG_KEYWORD,
|
||||
'MAX_SIZE' => Token::FLAG_KEYWORD,
|
||||
'MAX_UPDATES_PER_HOUR' => Token::FLAG_KEYWORD,
|
||||
'MAX_USER_CONNECTIONS' => Token::FLAG_KEYWORD,
|
||||
'MEDIUM' => Token::FLAG_KEYWORD,
|
||||
'MEMORY' => Token::FLAG_KEYWORD,
|
||||
'MERGE' => Token::FLAG_KEYWORD,
|
||||
'MESSAGE_TEXT' => Token::FLAG_KEYWORD,
|
||||
'MIGRATE' => Token::FLAG_KEYWORD,
|
||||
'MIN_ROWS' => Token::FLAG_KEYWORD,
|
||||
'MODE' => Token::FLAG_KEYWORD,
|
||||
'MODIFY' => Token::FLAG_KEYWORD,
|
||||
'MUTEX' => Token::FLAG_KEYWORD,
|
||||
'MYSQL_ERRNO' => Token::FLAG_KEYWORD,
|
||||
'NAME' => Token::FLAG_KEYWORD,
|
||||
'NAMES' => Token::FLAG_KEYWORD,
|
||||
'NATIONAL' => Token::FLAG_KEYWORD,
|
||||
'NCHAR' => Token::FLAG_KEYWORD,
|
||||
'NDB' => Token::FLAG_KEYWORD,
|
||||
'NDBCLUSTER' => Token::FLAG_KEYWORD,
|
||||
'NEW' => Token::FLAG_KEYWORD,
|
||||
'NEXT' => Token::FLAG_KEYWORD,
|
||||
'NO' => Token::FLAG_KEYWORD,
|
||||
'NODEGROUP' => Token::FLAG_KEYWORD,
|
||||
'NONE' => Token::FLAG_KEYWORD,
|
||||
'NO_WAIT' => Token::FLAG_KEYWORD,
|
||||
'NVARCHAR' => Token::FLAG_KEYWORD,
|
||||
'OFFSET' => Token::FLAG_KEYWORD,
|
||||
'ONE' => Token::FLAG_KEYWORD,
|
||||
'ONE_SHOT' => Token::FLAG_KEYWORD,
|
||||
'OPEN' => Token::FLAG_KEYWORD,
|
||||
'OPTIONS' => Token::FLAG_KEYWORD,
|
||||
'OWNER' => Token::FLAG_KEYWORD,
|
||||
'PACK_KEYS' => Token::FLAG_KEYWORD,
|
||||
'PAGE' => Token::FLAG_KEYWORD,
|
||||
'PARSER' => Token::FLAG_KEYWORD,
|
||||
'PARTIAL' => Token::FLAG_KEYWORD,
|
||||
'PARTITION' => Token::FLAG_KEYWORD,
|
||||
'PARTITIONING' => Token::FLAG_KEYWORD,
|
||||
'PARTITIONS' => Token::FLAG_KEYWORD,
|
||||
'PERSISTENT' => Token::FLAG_KEYWORD,
|
||||
'PHASE' => Token::FLAG_KEYWORD,
|
||||
'PLUGIN' => Token::FLAG_KEYWORD,
|
||||
'PLUGINS' => Token::FLAG_KEYWORD,
|
||||
'PORT' => Token::FLAG_KEYWORD,
|
||||
'PREPARE' => Token::FLAG_KEYWORD,
|
||||
'PRESERVE' => Token::FLAG_KEYWORD,
|
||||
'PREV' => Token::FLAG_KEYWORD,
|
||||
'PRIVILEGES' => Token::FLAG_KEYWORD,
|
||||
'PROCESSLIST' => Token::FLAG_KEYWORD,
|
||||
'PROFILE' => Token::FLAG_KEYWORD,
|
||||
'PROFILES' => Token::FLAG_KEYWORD,
|
||||
'PROXY' => Token::FLAG_KEYWORD,
|
||||
'QUERY' => Token::FLAG_KEYWORD,
|
||||
'QUICK' => Token::FLAG_KEYWORD,
|
||||
'READ_ONLY' => Token::FLAG_KEYWORD,
|
||||
'REBUILD' => Token::FLAG_KEYWORD,
|
||||
'RECOVER' => Token::FLAG_KEYWORD,
|
||||
'REDOFILE' => Token::FLAG_KEYWORD,
|
||||
'REDO_BUFFER_SIZE' => Token::FLAG_KEYWORD,
|
||||
'REDUNDANT' => Token::FLAG_KEYWORD,
|
||||
'RELAY' => Token::FLAG_KEYWORD,
|
||||
'RELAYLOG' => Token::FLAG_KEYWORD,
|
||||
'RELAY_LOG_FILE' => Token::FLAG_KEYWORD,
|
||||
'RELAY_LOG_POS' => Token::FLAG_KEYWORD,
|
||||
'RELAY_THREAD' => Token::FLAG_KEYWORD,
|
||||
'RELOAD' => Token::FLAG_KEYWORD,
|
||||
'REMOVE' => Token::FLAG_KEYWORD,
|
||||
'REORGANIZE' => Token::FLAG_KEYWORD,
|
||||
'REPAIR' => Token::FLAG_KEYWORD,
|
||||
'REPEATABLE' => Token::FLAG_KEYWORD,
|
||||
'REPLICATION' => Token::FLAG_KEYWORD,
|
||||
'RESET' => Token::FLAG_KEYWORD,
|
||||
'RESTORE' => Token::FLAG_KEYWORD,
|
||||
'RESUME' => Token::FLAG_KEYWORD,
|
||||
'RETURNS' => Token::FLAG_KEYWORD,
|
||||
'ROLLBACK' => Token::FLAG_KEYWORD,
|
||||
'ROLLUP' => Token::FLAG_KEYWORD,
|
||||
'ROUTINE' => Token::FLAG_KEYWORD,
|
||||
'ROW' => Token::FLAG_KEYWORD,
|
||||
'ROWS' => Token::FLAG_KEYWORD,
|
||||
'ROW_FORMAT' => Token::FLAG_KEYWORD,
|
||||
'RTREE' => Token::FLAG_KEYWORD,
|
||||
'SAVEPOINT' => Token::FLAG_KEYWORD,
|
||||
'SCHEDULE' => Token::FLAG_KEYWORD,
|
||||
'SCHEMA_NAME' => Token::FLAG_KEYWORD,
|
||||
'SECURITY' => Token::FLAG_KEYWORD,
|
||||
'SERIALIZABLE' => Token::FLAG_KEYWORD,
|
||||
'SERVER' => Token::FLAG_KEYWORD,
|
||||
'SESSION' => Token::FLAG_KEYWORD,
|
||||
'SHARE' => Token::FLAG_KEYWORD,
|
||||
'SHUTDOWN' => Token::FLAG_KEYWORD,
|
||||
'SIGNED' => Token::FLAG_KEYWORD,
|
||||
'SIMPLE' => Token::FLAG_KEYWORD,
|
||||
'SLAVE' => Token::FLAG_KEYWORD,
|
||||
'SLOW' => Token::FLAG_KEYWORD,
|
||||
'SNAPSHOT' => Token::FLAG_KEYWORD,
|
||||
'SOCKET' => Token::FLAG_KEYWORD,
|
||||
'SOME' => Token::FLAG_KEYWORD,
|
||||
'SONAME' => Token::FLAG_KEYWORD,
|
||||
'SOUNDS' => Token::FLAG_KEYWORD,
|
||||
'SOURCE' => Token::FLAG_KEYWORD,
|
||||
'SQL_BUFFER_RESULT' => Token::FLAG_KEYWORD,
|
||||
'SQL_CACHE' => Token::FLAG_KEYWORD,
|
||||
'SQL_NO_CACHE' => Token::FLAG_KEYWORD,
|
||||
'SQL_THREAD' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_DAY' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_FRAC_SECOND' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_HOUR' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_MINUTE' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_MONTH' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_QUARTER' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_SECOND' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_WEEK' => Token::FLAG_KEYWORD,
|
||||
'SQL_TSI_YEAR' => Token::FLAG_KEYWORD,
|
||||
'START' => Token::FLAG_KEYWORD,
|
||||
'STARTS' => Token::FLAG_KEYWORD,
|
||||
'STATUS' => Token::FLAG_KEYWORD,
|
||||
'STOP' => Token::FLAG_KEYWORD,
|
||||
'STORAGE' => Token::FLAG_KEYWORD,
|
||||
'STRING' => Token::FLAG_KEYWORD,
|
||||
'SUBCLASS_ORIGIN' => Token::FLAG_KEYWORD,
|
||||
'SUBJECT' => Token::FLAG_KEYWORD,
|
||||
'SUBPARTITION' => Token::FLAG_KEYWORD,
|
||||
'SUBPARTITIONS' => Token::FLAG_KEYWORD,
|
||||
'SUPER' => Token::FLAG_KEYWORD,
|
||||
'SUSPEND' => Token::FLAG_KEYWORD,
|
||||
'SWAPS' => Token::FLAG_KEYWORD,
|
||||
'SWITCHES' => Token::FLAG_KEYWORD,
|
||||
'TABLES' => Token::FLAG_KEYWORD,
|
||||
'TABLESPACE' => Token::FLAG_KEYWORD,
|
||||
'TABLE_CHECKSUM' => Token::FLAG_KEYWORD,
|
||||
'TABLE_NAME' => Token::FLAG_KEYWORD,
|
||||
'TEMPORARY' => Token::FLAG_KEYWORD,
|
||||
'TEMPTABLE' => Token::FLAG_KEYWORD,
|
||||
'THAN' => Token::FLAG_KEYWORD,
|
||||
'TRANSACTION' => Token::FLAG_KEYWORD,
|
||||
'TRIGGERS' => Token::FLAG_KEYWORD,
|
||||
'TYPE' => Token::FLAG_KEYWORD,
|
||||
'TYPES' => Token::FLAG_KEYWORD,
|
||||
'UNCOMMITTED' => Token::FLAG_KEYWORD,
|
||||
'UNDEFINED' => Token::FLAG_KEYWORD,
|
||||
'UNDOFILE' => Token::FLAG_KEYWORD,
|
||||
'UNDO_BUFFER_SIZE' => Token::FLAG_KEYWORD,
|
||||
'UNICODE' => Token::FLAG_KEYWORD,
|
||||
'UNINSTALL' => Token::FLAG_KEYWORD,
|
||||
'UNKNOWN' => Token::FLAG_KEYWORD,
|
||||
'UNTIL' => Token::FLAG_KEYWORD,
|
||||
'UPGRADE' => Token::FLAG_KEYWORD,
|
||||
'USER_RESOURCES' => Token::FLAG_KEYWORD,
|
||||
'USE_FRM' => Token::FLAG_KEYWORD,
|
||||
'VALUE' => Token::FLAG_KEYWORD,
|
||||
'VARIABLES' => Token::FLAG_KEYWORD,
|
||||
'VIEW' => Token::FLAG_KEYWORD,
|
||||
'VIRTUAL' => Token::FLAG_KEYWORD,
|
||||
'WAIT' => Token::FLAG_KEYWORD,
|
||||
'WARNINGS' => Token::FLAG_KEYWORD,
|
||||
'WORK' => Token::FLAG_KEYWORD,
|
||||
'WRAPPER' => Token::FLAG_KEYWORD,
|
||||
'X509' => Token::FLAG_KEYWORD,
|
||||
'XA' => Token::FLAG_KEYWORD,
|
||||
'ACCESSIBLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ALL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ALTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ANALYZE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'AND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'AS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ASC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ASENSITIVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BEFORE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BETWEEN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BOTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CALL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CASCADE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CHANGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CHECK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'COLLATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'COLUMN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CONDITION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CONSTRAINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CONTINUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CREATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CROSS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'CURSOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DATABASES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_HOUR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_MINUTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DAY_SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DEC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DECLARE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DELAYED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DELETE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DESC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DESCRIBE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DETERMINISTIC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DISTINCT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DISTINCTROW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DIV' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DROP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'DUAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'EACH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ELSE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ELSEIF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ENCLOSED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ESCAPED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'EXIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'EXPLAIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FALSE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FETCH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FORCE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FOREIGN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'FROM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'GRANT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'GROUP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HAVING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HIGH_PRIORITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HOUR_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HOUR_MINUTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'HOUR_SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'IGNORE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INFILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INNER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INOUT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INSENSITIVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'INTO' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'IS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ITERATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'KEYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'KILL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LEADING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LEAVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LIKE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LIMIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LINEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LINES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOAD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOOP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'LOW_PRIORITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MASTER_SSL_VERIFY_SERVER_CERT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MAXVALUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MINUTE_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MINUTE_SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'MODIFIES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NATURAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NOT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NO_WRITE_TO_BINLOG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'NULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OPTIMIZE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OPTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OPTIONALLY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ORDER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OUT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OUTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'OUTFILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PRECISION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PRIMARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PROCEDURE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'PURGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RANGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'READ' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'READS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'READ_WRITE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REFERENCES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REGEXP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RELEASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RENAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REQUIRE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RESIGNAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RESTRICT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RETURN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'REVOKE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'RLIKE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SCHEMAS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SECOND_MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SELECT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SENSITIVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SEPARATOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SHOW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SIGNAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SPECIFIC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQLEXCEPTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQLSTATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQLWARNING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL_BIG_RESULT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL_CALC_FOUND_ROWS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SQL_SMALL_RESULT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'SSL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'STARTING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'STRAIGHT_JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TABLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TERMINATED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'THEN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TO' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TRAILING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TRIGGER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'TRUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNDO' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNLOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UNSIGNED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'UPDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'USAGE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'USE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'USING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'VARCHARACTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'VARYING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WHEN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WHERE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WHILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WITH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'WRITE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'XOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'YEAR_MONTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'ZEROFILL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED,
|
||||
'AND CHAIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'AND NO CHAIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'CHARACTER SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'COALESCE PARTITION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'CONTAINS SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'CROSS JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DATA DIRECTORY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DEFAULT CHARACTER SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DEFAULT CHARSET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DEFAULT COLLATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'DISABLE ON SLAVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ENCLOSED BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ESCAPED BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FOR EACH ROW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FOR UPDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FULL JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'FULL OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'GENERATED ALWAYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'GROUP BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'IF EXISTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'IF NOT EXISTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'INDEX DIRECTORY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'INNER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LANGUAGE SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LEFT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LEFT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LESS THAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LINEAR HASH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LINEAR KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LOAD DATA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'LOCK IN SHARE MODE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'MODIFIES SQL DATA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL LEFT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL LEFT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL RIGHT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NATURAL RIGHT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NO ACTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NO RELEASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NO SQL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'NOT NULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON COMPLETION NOT PRESERVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON COMPLETION PRESERVE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON DELETE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON SCHEDULE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ON UPDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'OR REPLACE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ORDER BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'PARTITION BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'READS SQL DATA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'RIGHT JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'RIGHT OUTER JOIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SELECT TRANSACTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SET NULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SET PASSWORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SQL SECURITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'START TRANSACTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'STARTING BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'SUBPARTITION BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'TERMINATED BY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'UNION ALL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'UNION DISTINCT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'WITH CONSISTENT SNAPSHOT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'WITH PARSER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'WITH ROLLUP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED,
|
||||
'ARRAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BOOL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BOOLEAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'DATETIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'ENUM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FIXED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'GEOMETRY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'JSON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MULTILINEPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MULTILINEPOLYGON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MULTISET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'SERIAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'XML' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BIGINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'CHARACTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'DECIMAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'DOUBLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FLOAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FLOAT4' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FLOAT8' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT1' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT3' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT4' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INT8' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'INTEGER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONGBLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONGTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MEDIUMBLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MEDIUMINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MEDIUMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'MIDDLEINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'NUMERIC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'REAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'SMALLINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TINYBLOB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TINYINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'TINYTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'VARBINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'VARCHAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'BINARY VARYING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'CHARACTER VARYING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONG VARBINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'LONG VARCHAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'FULLTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'SPATIAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'UNIQUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_KEY,
|
||||
'FOREIGN KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'FULLTEXT INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'FULLTEXT KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'INDEX KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'PRIMARY KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'SPATIAL INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'SPATIAL KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'UNIQUE INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'UNIQUE KEY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_KEY,
|
||||
'ABS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ACOS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ADDDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ADDTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AES_DECRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AES_ENCRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AGAINST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AREA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASBINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASCII' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ASWKT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ATAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ATAN2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'AVG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BENCHMARK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_AND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_COUNT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_OR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BIT_XOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CAST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CEIL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CEILING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CENTROID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHARACTER_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHARSET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHAR_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COALESCE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COERCIBILITY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COLLATION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COMPRESS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONCAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONCAT_WS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONNECTION_ID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONTAINS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONV' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONVERT_TZ' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'COUNT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CRC32' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CROSSES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATEDIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE_ADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE_FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE_SUB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYNAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYOFMONTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYOFWEEK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DAYOFYEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DECODE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DEGREES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DES_DECRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DES_ENCRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DIMENSION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DISJOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ELT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENCODE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENCRYPT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENDPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ENVELOPE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EQUALS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXPORT_SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXTERIORRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXTRACT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXTRACTVALUE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FIELD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FIND_IN_SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FLOOR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FOUND_ROWS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FROM_DAYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'FROM_UNIXTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMCOLLFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMCOLLFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYCOLLECTIONFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYCOLLECTIONFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYTYPE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GET_FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GET_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GLENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GREATEST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GROUP_CONCAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'HEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'HOUR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IFNULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INET_ATON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INET_NTOA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INSTR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INTERIORRINGN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INTERSECTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISCLOSED' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISEMPTY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISNULL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ISSIMPLE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IS_FREE_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IS_USED_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LAST_DAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LAST_INSERT_ID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LCASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LEAST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINEFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINEFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINESTRINGFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINESTRINGFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOAD_FILE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOCATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOG' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOG10' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOG2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOWER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LPAD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LTRIM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAKEDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAKETIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAKE_SET' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MASTER_POS_WAIT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MAX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRCONTAINS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRDISJOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBREQUAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRINTERSECTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBROVERLAPS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRTOUCHES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MBRWITHIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MD5' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MICROSECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MINUTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MLINEFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MLINEFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MONTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MONTHNAME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOINTFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOINTFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOLYFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MPOLYFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTILINESTRINGFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTILINESTRINGFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOINTFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOINTFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOLYGONFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOLYGONFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NAME_CONST' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NOW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NULLIF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NUMGEOMETRIES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NUMINTERIORRINGS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NUMPOINTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OCT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OCTET_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OLD_PASSWORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'OVERLAPS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PASSWORD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PERIOD_ADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PERIOD_DIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'PI' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINTFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINTFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINTN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYGONFROMTEXT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYGONFROMWKB' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POSITION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POW' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POWER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'QUARTER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'QUOTE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RADIANS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RAND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RELEASE_LOCK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'REVERSE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ROUND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'ROW_COUNT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RPAD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RTRIM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SECOND' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SEC_TO_TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SESSION_USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SHA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SHA1' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SHA2' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SIGN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SLEEP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SOUNDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SPACE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SQRT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SRID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STARTPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STDDEV' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STDDEV_POP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STDDEV_SAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STRCMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'STR_TO_DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBSTR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBSTRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBSTRING_INDEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUBTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SUM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SYSDATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SYSTEM_USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TAN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMEDIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMESTAMPADD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMESTAMPDIFF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIME_FORMAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIME_TO_SEC' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TOUCHES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TO_DAYS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TO_SECONDS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TRIM' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TRUNCATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UCASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNCOMPRESS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNCOMPRESSED_LENGTH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNHEX' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UNIX_TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UPDATEXML' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UPPER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UUID' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UUID_SHORT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VARIANCE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VAR_POP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VAR_SAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VERSION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WEEK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WEEKDAY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WEEKOFYEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'WITHIN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'X' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'Y' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'YEARWEEK' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CONVERT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CURRENT_USER' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATABASE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DEFAULT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'EXISTS' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IF' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'IN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INSERT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LEFT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOCALTIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LOCALTIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MATCH' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MOD' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'REPEAT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'REPLACE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'RIGHT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'SCHEMA' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UTC_DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UTC_TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'UTC_TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'VALUES' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'NOT IN' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_COMPOSED | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'DATE' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'GEOMETRYCOLLECTION' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'LINESTRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTILINESTRING' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'MULTIPOLYGON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POINT' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'POLYGON' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIME' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'TIMESTAMP' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'YEAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'BINARY' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'CHAR' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
'INTERVAL' => Token::FLAG_KEYWORD | Token::FLAG_KEYWORD_RESERVED | Token::FLAG_KEYWORD_DATA_TYPE | Token::FLAG_KEYWORD_FUNCTION,
|
||||
];
|
||||
}
|
||||
+1013
File diff suppressed because it is too large
Load Diff
+1097
File diff suppressed because it is too large
Load Diff
+1119
File diff suppressed because it is too large
Load Diff
+1109
File diff suppressed because it is too large
Load Diff
+1108
File diff suppressed because it is too large
Load Diff
+1108
File diff suppressed because it is too large
Load Diff
+1096
File diff suppressed because it is too large
Load Diff
+1090
File diff suppressed because it is too large
Load Diff
+1090
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,53 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser;
|
||||
|
||||
use Exception;
|
||||
|
||||
/**
|
||||
* Defines the core helper infrastructure of the library.
|
||||
*/
|
||||
class Core
|
||||
{
|
||||
/**
|
||||
* Whether errors should throw exceptions or just be stored.
|
||||
*
|
||||
* @see static::$errors
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
public $strict = false;
|
||||
|
||||
/**
|
||||
* List of errors that occurred during lexing.
|
||||
*
|
||||
* Usually, the lexing does not stop once an error occurred because that
|
||||
* error might be false positive or a partial result (even a bad one)
|
||||
* might be needed.
|
||||
*
|
||||
* @see Core::error()
|
||||
*
|
||||
* @var Exception[]
|
||||
*/
|
||||
public $errors = [];
|
||||
|
||||
/**
|
||||
* Creates a new error log.
|
||||
*
|
||||
* @param Exception $error the error exception
|
||||
*
|
||||
* @return void
|
||||
*
|
||||
* @throws Exception throws the exception, if strict mode is enabled.
|
||||
*/
|
||||
public function error($error)
|
||||
{
|
||||
if ($this->strict) {
|
||||
throw $error;
|
||||
}
|
||||
|
||||
$this->errors[] = $error;
|
||||
}
|
||||
}
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Exceptions;
|
||||
|
||||
use Exception;
|
||||
|
||||
/**
|
||||
* Exception thrown by the lexer.
|
||||
*/
|
||||
class LexerException extends Exception
|
||||
{
|
||||
/**
|
||||
* The character that produced this error.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $ch;
|
||||
|
||||
/**
|
||||
* The index of the character that produced this error.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
public $pos;
|
||||
|
||||
/**
|
||||
* @param string $msg the message of this exception
|
||||
* @param string $ch the character that produced this exception
|
||||
* @param int $pos the position of the character
|
||||
* @param int $code the code of this error
|
||||
*/
|
||||
public function __construct($msg = '', $ch = '', $pos = 0, $code = 0)
|
||||
{
|
||||
parent::__construct($msg, $code);
|
||||
$this->ch = $ch;
|
||||
$this->pos = $pos;
|
||||
}
|
||||
}
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Exceptions;
|
||||
|
||||
use Exception;
|
||||
|
||||
/**
|
||||
* Exception thrown by the lexer.
|
||||
*/
|
||||
class LoaderException extends Exception
|
||||
{
|
||||
/**
|
||||
* The failed load name.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $name;
|
||||
|
||||
/**
|
||||
* @param string $msg the message of this exception
|
||||
* @param string $name the character that produced this exception
|
||||
* @param int $code the code of this error
|
||||
*/
|
||||
public function __construct($msg = '', $name = '', $code = 0)
|
||||
{
|
||||
parent::__construct($msg, $code);
|
||||
$this->name = $name;
|
||||
}
|
||||
}
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Exceptions;
|
||||
|
||||
use Exception;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
|
||||
/**
|
||||
* Exception thrown by the parser.
|
||||
*/
|
||||
class ParserException extends Exception
|
||||
{
|
||||
/**
|
||||
* The token that produced this error.
|
||||
*
|
||||
* @var Token|null
|
||||
*/
|
||||
public $token;
|
||||
|
||||
/**
|
||||
* @param string $msg the message of this exception
|
||||
* @param Token|null $token the token that produced this exception
|
||||
* @param int $code the code of this error
|
||||
*/
|
||||
public function __construct($msg = '', ?Token $token = null, $code = 0)
|
||||
{
|
||||
parent::__construct($msg, $code);
|
||||
$this->token = $token;
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,635 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Exceptions\ParserException;
|
||||
use PhpMyAdmin\SqlParser\Statements\SelectStatement;
|
||||
use PhpMyAdmin\SqlParser\Statements\TransactionStatement;
|
||||
|
||||
use function is_string;
|
||||
use function strtoupper;
|
||||
|
||||
/**
|
||||
* Defines the parser of the library.
|
||||
*
|
||||
* This is one of the most important components, along with the lexer.
|
||||
*
|
||||
* Takes multiple tokens (contained in a Lexer instance) as input and builds a parse tree.
|
||||
*/
|
||||
class Parser extends Core
|
||||
{
|
||||
/**
|
||||
* Array of classes that are used in parsing the SQL statements.
|
||||
*
|
||||
* @var array<string, string>
|
||||
*/
|
||||
public static $STATEMENT_PARSERS = [
|
||||
// MySQL Utility Statements
|
||||
'DESCRIBE' => 'PhpMyAdmin\\SqlParser\\Statements\\ExplainStatement',
|
||||
'DESC' => 'PhpMyAdmin\\SqlParser\\Statements\\ExplainStatement',
|
||||
'EXPLAIN' => 'PhpMyAdmin\\SqlParser\\Statements\\ExplainStatement',
|
||||
'FLUSH' => '',
|
||||
'GRANT' => '',
|
||||
'HELP' => '',
|
||||
'SET PASSWORD' => '',
|
||||
'STATUS' => '',
|
||||
'USE' => '',
|
||||
|
||||
// Table Maintenance Statements
|
||||
// https://dev.mysql.com/doc/refman/5.7/en/table-maintenance-sql.html
|
||||
'ANALYZE' => 'PhpMyAdmin\\SqlParser\\Statements\\AnalyzeStatement',
|
||||
'BACKUP' => 'PhpMyAdmin\\SqlParser\\Statements\\BackupStatement',
|
||||
'CHECK' => 'PhpMyAdmin\\SqlParser\\Statements\\CheckStatement',
|
||||
'CHECKSUM' => 'PhpMyAdmin\\SqlParser\\Statements\\ChecksumStatement',
|
||||
'KILL' => 'PhpMyAdmin\\SqlParser\\Statements\\KillStatement',
|
||||
'OPTIMIZE' => 'PhpMyAdmin\\SqlParser\\Statements\\OptimizeStatement',
|
||||
'REPAIR' => 'PhpMyAdmin\\SqlParser\\Statements\\RepairStatement',
|
||||
'RESTORE' => 'PhpMyAdmin\\SqlParser\\Statements\\RestoreStatement',
|
||||
|
||||
// Database Administration Statements
|
||||
// https://dev.mysql.com/doc/refman/5.7/en/sql-syntax-server-administration.html
|
||||
'SET' => 'PhpMyAdmin\\SqlParser\\Statements\\SetStatement',
|
||||
'SHOW' => 'PhpMyAdmin\\SqlParser\\Statements\\ShowStatement',
|
||||
|
||||
// Data Definition Statements.
|
||||
// https://dev.mysql.com/doc/refman/5.7/en/sql-syntax-data-definition.html
|
||||
'ALTER' => 'PhpMyAdmin\\SqlParser\\Statements\\AlterStatement',
|
||||
'CREATE' => 'PhpMyAdmin\\SqlParser\\Statements\\CreateStatement',
|
||||
'DROP' => 'PhpMyAdmin\\SqlParser\\Statements\\DropStatement',
|
||||
'RENAME' => 'PhpMyAdmin\\SqlParser\\Statements\\RenameStatement',
|
||||
'TRUNCATE' => 'PhpMyAdmin\\SqlParser\\Statements\\TruncateStatement',
|
||||
|
||||
// Data Manipulation Statements.
|
||||
// https://dev.mysql.com/doc/refman/5.7/en/sql-syntax-data-manipulation.html
|
||||
'CALL' => 'PhpMyAdmin\\SqlParser\\Statements\\CallStatement',
|
||||
'DELETE' => 'PhpMyAdmin\\SqlParser\\Statements\\DeleteStatement',
|
||||
'DO' => '',
|
||||
'HANDLER' => '',
|
||||
'INSERT' => 'PhpMyAdmin\\SqlParser\\Statements\\InsertStatement',
|
||||
'LOAD DATA' => 'PhpMyAdmin\\SqlParser\\Statements\\LoadStatement',
|
||||
'REPLACE' => 'PhpMyAdmin\\SqlParser\\Statements\\ReplaceStatement',
|
||||
'SELECT' => 'PhpMyAdmin\\SqlParser\\Statements\\SelectStatement',
|
||||
'UPDATE' => 'PhpMyAdmin\\SqlParser\\Statements\\UpdateStatement',
|
||||
'WITH' => 'PhpMyAdmin\\SqlParser\\Statements\\WithStatement',
|
||||
|
||||
// Prepared Statements.
|
||||
// https://dev.mysql.com/doc/refman/5.7/en/sql-syntax-prepared-statements.html
|
||||
'DEALLOCATE' => '',
|
||||
'EXECUTE' => '',
|
||||
'PREPARE' => '',
|
||||
|
||||
// Transactional and Locking Statements
|
||||
// https://dev.mysql.com/doc/refman/5.7/en/commit.html
|
||||
'BEGIN' => 'PhpMyAdmin\\SqlParser\\Statements\\TransactionStatement',
|
||||
'COMMIT' => 'PhpMyAdmin\\SqlParser\\Statements\\TransactionStatement',
|
||||
'ROLLBACK' => 'PhpMyAdmin\\SqlParser\\Statements\\TransactionStatement',
|
||||
'START TRANSACTION' => 'PhpMyAdmin\\SqlParser\\Statements\\TransactionStatement',
|
||||
|
||||
'PURGE' => 'PhpMyAdmin\\SqlParser\\Statements\\PurgeStatement',
|
||||
|
||||
// Lock statements
|
||||
// https://dev.mysql.com/doc/refman/5.7/en/lock-tables.html
|
||||
'LOCK' => 'PhpMyAdmin\\SqlParser\\Statements\\LockStatement',
|
||||
'UNLOCK' => 'PhpMyAdmin\\SqlParser\\Statements\\LockStatement',
|
||||
];
|
||||
|
||||
/**
|
||||
* Array of classes that are used in parsing SQL components.
|
||||
*
|
||||
* @var array<string, array<string, string|array<string, string>>>
|
||||
* @psalm-var array<string, array{class?: string, field?: non-empty-string, options?: array<string, string>}>
|
||||
*/
|
||||
public static $KEYWORD_PARSERS = [
|
||||
// This is not a proper keyword and was added here to help the
|
||||
// formatter.
|
||||
'PARTITION BY' => [],
|
||||
'SUBPARTITION BY' => [],
|
||||
|
||||
// This is not a proper keyword and was added here to help the
|
||||
// builder.
|
||||
'_OPTIONS' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\OptionsArray',
|
||||
'field' => 'options',
|
||||
],
|
||||
'_END_OPTIONS' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\OptionsArray',
|
||||
'field' => 'end_options',
|
||||
],
|
||||
'_GROUP_OPTIONS' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\OptionsArray',
|
||||
'field' => 'group_options',
|
||||
],
|
||||
|
||||
'INTERSECT' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\UnionKeyword',
|
||||
'field' => 'union',
|
||||
],
|
||||
'EXCEPT' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\UnionKeyword',
|
||||
'field' => 'union',
|
||||
],
|
||||
'UNION' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\UnionKeyword',
|
||||
'field' => 'union',
|
||||
],
|
||||
'UNION ALL' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\UnionKeyword',
|
||||
'field' => 'union',
|
||||
],
|
||||
'UNION DISTINCT' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\UnionKeyword',
|
||||
'field' => 'union',
|
||||
],
|
||||
|
||||
// Actual clause parsers.
|
||||
'ALTER' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\Expression',
|
||||
'field' => 'table',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'ANALYZE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'tables',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'BACKUP' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'tables',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'CALL' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\FunctionCall',
|
||||
'field' => 'call',
|
||||
],
|
||||
'CHECK' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'tables',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'CHECKSUM' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'tables',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'CROSS JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'DROP' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'fields',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'FORCE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\IndexHint',
|
||||
'field' => 'index_hints',
|
||||
],
|
||||
'FROM' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'from',
|
||||
'options' => ['field' => 'table'],
|
||||
],
|
||||
'GROUP BY' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\GroupKeyword',
|
||||
'field' => 'group',
|
||||
],
|
||||
'HAVING' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\Condition',
|
||||
'field' => 'having',
|
||||
],
|
||||
'IGNORE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\IndexHint',
|
||||
'field' => 'index_hints',
|
||||
],
|
||||
'INTO' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\IntoKeyword',
|
||||
'field' => 'into',
|
||||
],
|
||||
'JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'LEFT JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'LEFT OUTER JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'ON' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\Expression',
|
||||
'field' => 'table',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'RIGHT JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'RIGHT OUTER JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'INNER JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'FULL JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'FULL OUTER JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'NATURAL JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'NATURAL LEFT JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'NATURAL RIGHT JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'NATURAL LEFT OUTER JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'NATURAL RIGHT OUTER JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'STRAIGHT_JOIN' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\JoinKeyword',
|
||||
'field' => 'join',
|
||||
],
|
||||
'LIMIT' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\Limit',
|
||||
'field' => 'limit',
|
||||
],
|
||||
'OPTIMIZE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'tables',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'ORDER BY' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\OrderKeyword',
|
||||
'field' => 'order',
|
||||
],
|
||||
'PARTITION' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ArrayObj',
|
||||
'field' => 'partition',
|
||||
],
|
||||
'PROCEDURE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\FunctionCall',
|
||||
'field' => 'procedure',
|
||||
],
|
||||
'RENAME' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\RenameOperation',
|
||||
'field' => 'renames',
|
||||
],
|
||||
'REPAIR' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'tables',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'RESTORE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'tables',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'SET' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\SetOperation',
|
||||
'field' => 'set',
|
||||
],
|
||||
'SELECT' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'expr',
|
||||
],
|
||||
'TRUNCATE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\Expression',
|
||||
'field' => 'table',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'UPDATE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\ExpressionArray',
|
||||
'field' => 'tables',
|
||||
'options' => ['parseField' => 'table'],
|
||||
],
|
||||
'USE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\IndexHint',
|
||||
'field' => 'index_hints',
|
||||
],
|
||||
'VALUE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\Array2d',
|
||||
'field' => 'values',
|
||||
],
|
||||
'VALUES' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\Array2d',
|
||||
'field' => 'values',
|
||||
],
|
||||
'WHERE' => [
|
||||
'class' => 'PhpMyAdmin\\SqlParser\\Components\\Condition',
|
||||
'field' => 'where',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* The list of tokens that are parsed.
|
||||
*
|
||||
* @var TokensList|null
|
||||
*/
|
||||
public $list;
|
||||
|
||||
/**
|
||||
* List of statements parsed.
|
||||
*
|
||||
* @var Statement[]
|
||||
*/
|
||||
public $statements = [];
|
||||
|
||||
/**
|
||||
* The number of opened brackets.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
public $brackets = 0;
|
||||
|
||||
/**
|
||||
* @param string|UtfString|TokensList|null $list the list of tokens to be parsed
|
||||
* @param bool $strict whether strict mode should be enabled or not
|
||||
*/
|
||||
public function __construct($list = null, $strict = false)
|
||||
{
|
||||
if (is_string($list) || ($list instanceof UtfString)) {
|
||||
$lexer = new Lexer($list, $strict);
|
||||
$this->list = $lexer->list;
|
||||
} elseif ($list instanceof TokensList) {
|
||||
$this->list = $list;
|
||||
}
|
||||
|
||||
$this->strict = $strict;
|
||||
|
||||
if ($list === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->parse();
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the parse trees.
|
||||
*
|
||||
* @return void
|
||||
*
|
||||
* @throws ParserException
|
||||
*/
|
||||
public function parse()
|
||||
{
|
||||
/**
|
||||
* Last transaction.
|
||||
*
|
||||
* @var TransactionStatement
|
||||
*/
|
||||
$lastTransaction = null;
|
||||
|
||||
/**
|
||||
* Last parsed statement.
|
||||
*
|
||||
* @var Statement
|
||||
*/
|
||||
$lastStatement = null;
|
||||
|
||||
/**
|
||||
* Union's type or false for no union.
|
||||
*
|
||||
* @var bool|string
|
||||
*/
|
||||
$unionType = false;
|
||||
|
||||
/**
|
||||
* The index of the last token from the last statement.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$prevLastIdx = -1;
|
||||
|
||||
/**
|
||||
* The list of tokens.
|
||||
*/
|
||||
$list = &$this->list;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// `DELIMITER` is not an actual statement and it requires
|
||||
// special handling.
|
||||
if (($token->type === Token::TYPE_NONE) && (strtoupper($token->token) === 'DELIMITER')) {
|
||||
// Skipping to the end of this statement.
|
||||
$list->getNextOfType(Token::TYPE_DELIMITER);
|
||||
$prevLastIdx = $list->idx;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Counting the brackets around statements.
|
||||
if ($token->value === '(') {
|
||||
++$this->brackets;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Statements can start with keywords only.
|
||||
// Comments, whitespaces, etc. are ignored.
|
||||
if ($token->type !== Token::TYPE_KEYWORD) {
|
||||
if (
|
||||
($token->type !== Token::TYPE_COMMENT)
|
||||
&& ($token->type !== Token::TYPE_WHITESPACE)
|
||||
&& ($token->type !== Token::TYPE_OPERATOR) // `(` and `)`
|
||||
&& ($token->type !== Token::TYPE_DELIMITER)
|
||||
) {
|
||||
$this->error('Unexpected beginning of statement.', $token);
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (
|
||||
($token->keyword === 'UNION') ||
|
||||
($token->keyword === 'UNION ALL') ||
|
||||
($token->keyword === 'UNION DISTINCT') ||
|
||||
($token->keyword === 'EXCEPT') ||
|
||||
($token->keyword === 'INTERSECT')
|
||||
) {
|
||||
$unionType = $token->keyword;
|
||||
continue;
|
||||
}
|
||||
|
||||
$lastIdx = $list->idx;
|
||||
$statementName = null;
|
||||
|
||||
if ($token->keyword === 'ANALYZE') {
|
||||
++$list->idx; // Skip ANALYZE
|
||||
|
||||
$first = $list->getNextOfType(Token::TYPE_KEYWORD);
|
||||
$second = $list->getNextOfType(Token::TYPE_KEYWORD);
|
||||
|
||||
// ANALYZE keyword can be an indication of two cases:
|
||||
// 1 - ANALYZE TABLE statements, in both MariaDB and MySQL
|
||||
// 2 - Explain statement, in case of MariaDB https://mariadb.com/kb/en/explain-analyze/
|
||||
// We need to point case 2 to use the EXPLAIN Parser.
|
||||
$statementName = 'EXPLAIN';
|
||||
if (($first && $first->keyword === 'TABLE') || ($second && $second->keyword === 'TABLE')) {
|
||||
$statementName = 'ANALYZE';
|
||||
}
|
||||
|
||||
$list->idx = $lastIdx;
|
||||
} else {
|
||||
// Checking if it is a known statement that can be parsed.
|
||||
if (empty(static::$STATEMENT_PARSERS[$token->keyword])) {
|
||||
if (! isset(static::$STATEMENT_PARSERS[$token->keyword])) {
|
||||
// A statement is considered recognized if the parser
|
||||
// is aware that it is a statement, but it does not have
|
||||
// a parser for it yet.
|
||||
$this->error('Unrecognized statement type.', $token);
|
||||
}
|
||||
|
||||
// Skipping to the end of this statement.
|
||||
$list->getNextOfType(Token::TYPE_DELIMITER);
|
||||
$prevLastIdx = $list->idx;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The name of the class that is used for parsing.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$class = static::$STATEMENT_PARSERS[$statementName ?? $token->keyword];
|
||||
|
||||
/**
|
||||
* Processed statement.
|
||||
*
|
||||
* @var Statement
|
||||
*/
|
||||
$statement = new $class($this, $this->list);
|
||||
|
||||
// The first token that is a part of this token is the next token
|
||||
// unprocessed by the previous statement.
|
||||
// There might be brackets around statements and this shouldn't
|
||||
// affect the parser
|
||||
$statement->first = $prevLastIdx + 1;
|
||||
|
||||
// Storing the index of the last token parsed and updating the old
|
||||
// index.
|
||||
$statement->last = $list->idx;
|
||||
$prevLastIdx = $list->idx;
|
||||
|
||||
// Handles unions.
|
||||
if (
|
||||
! empty($unionType)
|
||||
&& ($lastStatement instanceof SelectStatement)
|
||||
&& ($statement instanceof SelectStatement)
|
||||
) {
|
||||
/*
|
||||
* This SELECT statement.
|
||||
*
|
||||
* @var SelectStatement $statement
|
||||
*/
|
||||
|
||||
/*
|
||||
* Last SELECT statement.
|
||||
*
|
||||
* @var SelectStatement $lastStatement
|
||||
*/
|
||||
$lastStatement->union[] = [
|
||||
$unionType,
|
||||
$statement,
|
||||
];
|
||||
|
||||
// if there are no no delimiting brackets, the `ORDER` and
|
||||
// `LIMIT` keywords actually belong to the first statement.
|
||||
$lastStatement->order = $statement->order;
|
||||
$lastStatement->limit = $statement->limit;
|
||||
$statement->order = [];
|
||||
$statement->limit = null;
|
||||
|
||||
// The statement actually ends where the last statement in
|
||||
// union ends.
|
||||
$lastStatement->last = $statement->last;
|
||||
|
||||
$unionType = false;
|
||||
|
||||
// Validate clause order
|
||||
$statement->validateClauseOrder($this, $list);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Handles transactions.
|
||||
if ($statement instanceof TransactionStatement) {
|
||||
/*
|
||||
* @var TransactionStatement
|
||||
*/
|
||||
if ($statement->type === TransactionStatement::TYPE_BEGIN) {
|
||||
$lastTransaction = $statement;
|
||||
$this->statements[] = $statement;
|
||||
} elseif ($statement->type === TransactionStatement::TYPE_END) {
|
||||
if ($lastTransaction === null) {
|
||||
// Even though an error occurred, the query is being
|
||||
// saved.
|
||||
$this->statements[] = $statement;
|
||||
$this->error('No transaction was previously started.', $token);
|
||||
} else {
|
||||
$lastTransaction->end = $statement;
|
||||
}
|
||||
|
||||
$lastTransaction = null;
|
||||
}
|
||||
|
||||
// Validate clause order
|
||||
$statement->validateClauseOrder($this, $list);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Validate clause order
|
||||
$statement->validateClauseOrder($this, $list);
|
||||
|
||||
// Finally, storing the statement.
|
||||
if ($lastTransaction !== null) {
|
||||
$lastTransaction->statements[] = $statement;
|
||||
} else {
|
||||
$this->statements[] = $statement;
|
||||
}
|
||||
|
||||
$lastStatement = $statement;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new error log.
|
||||
*
|
||||
* @param string $msg the error message
|
||||
* @param Token $token the token that produced the error
|
||||
* @param int $code the code of the error
|
||||
*
|
||||
* @return void
|
||||
*
|
||||
* @throws ParserException throws the exception, if strict mode is enabled.
|
||||
*/
|
||||
public function error($msg, ?Token $token = null, $code = 0)
|
||||
{
|
||||
$error = new ParserException(
|
||||
Translator::gettext($msg),
|
||||
$token,
|
||||
$code
|
||||
);
|
||||
parent::error($error);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,585 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use Stringable;
|
||||
|
||||
use function array_flip;
|
||||
use function array_keys;
|
||||
use function array_push;
|
||||
use function count;
|
||||
use function in_array;
|
||||
use function stripos;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* The result of the parser is an array of statements are extensions of the class defined here.
|
||||
*
|
||||
* A statement represents the result of parsing the lexemes.
|
||||
*
|
||||
* Abstract statement definition.
|
||||
*/
|
||||
#[\AllowDynamicProperties]
|
||||
abstract class Statement implements Stringable
|
||||
{
|
||||
/**
|
||||
* Options for this statement.
|
||||
*
|
||||
* The option would be the key and the value can be an integer or an array.
|
||||
*
|
||||
* The integer represents only the index used.
|
||||
*
|
||||
* The array may have two keys: `0` is used to represent the index used and
|
||||
* `1` is the type of the option (which may be 'var' or 'var='). Both
|
||||
* options mean they expect a value after the option (e.g. `A = B` or `A B`,
|
||||
* in which case `A` is the key and `B` is the value). The only difference
|
||||
* is in the building process. `var` options are built as `A B` and `var=`
|
||||
* options are built as `A = B`
|
||||
*
|
||||
* Two options that can be used together must have different values for
|
||||
* indexes, else, when they will be used together, an error will occur.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [];
|
||||
|
||||
/**
|
||||
* The clauses of this statement, in order.
|
||||
*
|
||||
* The value attributed to each clause is used by the builder and it may
|
||||
* have one of the following values:
|
||||
*
|
||||
* - 1 = 01 - add the clause only
|
||||
* - 2 = 10 - add the keyword
|
||||
* - 3 = 11 - add both the keyword and the clause
|
||||
*
|
||||
* @var array<string, array<int, int|string>>
|
||||
* @psalm-var array<string, array{non-empty-string, (1|2|3)}>
|
||||
*/
|
||||
public static $CLAUSES = [];
|
||||
|
||||
/**
|
||||
* Options that can be given to GROUP BY component.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $GROUP_OPTIONS = [];
|
||||
|
||||
/**
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $END_OPTIONS = [];
|
||||
|
||||
/**
|
||||
* The options of this query.
|
||||
*
|
||||
* @see static::$OPTIONS
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $options;
|
||||
|
||||
/**
|
||||
* The index of the first token used in this statement.
|
||||
*
|
||||
* @var int|null
|
||||
*/
|
||||
public $first;
|
||||
|
||||
/**
|
||||
* The index of the last token used in this statement.
|
||||
*
|
||||
* @var int|null
|
||||
*/
|
||||
public $last;
|
||||
|
||||
/**
|
||||
* @param Parser|null $parser the instance that requests parsing
|
||||
* @param TokensList|null $list the list of tokens to be parsed
|
||||
*/
|
||||
public function __construct(?Parser $parser = null, ?TokensList $list = null)
|
||||
{
|
||||
if (($parser === null) || ($list === null)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->parse($parser, $list);
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the string representation of this statement.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
/**
|
||||
* Query to be returned.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$query = '';
|
||||
|
||||
/**
|
||||
* Clauses which were built already.
|
||||
*
|
||||
* It is required to keep track of built clauses because some fields,
|
||||
* for example `join` is used by multiple clauses (`JOIN`, `LEFT JOIN`,
|
||||
* `LEFT OUTER JOIN`, etc.). The same happens for `VALUE` and `VALUES`.
|
||||
*
|
||||
* A clause is considered built just after fields' value
|
||||
* (`$this->field`) was used in building.
|
||||
*/
|
||||
$built = [];
|
||||
|
||||
/**
|
||||
* Statement's clauses.
|
||||
*/
|
||||
$clauses = $this->getClauses();
|
||||
|
||||
foreach ($clauses as $clause) {
|
||||
/**
|
||||
* The name of the clause.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$name = $clause[0];
|
||||
|
||||
/**
|
||||
* The type of the clause.
|
||||
*
|
||||
* @see self::$CLAUSES
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$type = $clause[1];
|
||||
|
||||
/**
|
||||
* The builder (parser) of this clause.
|
||||
*
|
||||
* @var Component
|
||||
*/
|
||||
$class = Parser::$KEYWORD_PARSERS[$name]['class'];
|
||||
|
||||
/**
|
||||
* The name of the field that is used as source for the builder.
|
||||
* Same field is used to store the result of parsing.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$field = Parser::$KEYWORD_PARSERS[$name]['field'];
|
||||
|
||||
// The field is empty, there is nothing to be built.
|
||||
if (empty($this->$field)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Checking if this field was already built.
|
||||
if ($type & 1) {
|
||||
if (! empty($built[$field])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$built[$field] = true;
|
||||
}
|
||||
|
||||
// Checking if the name of the clause should be added.
|
||||
if ($type & 2) {
|
||||
$query = trim($query) . ' ' . $name;
|
||||
}
|
||||
|
||||
// Checking if the result of the builder should be added.
|
||||
if (! ($type & 1)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$query = trim($query) . ' ' . $class::build($this->$field);
|
||||
}
|
||||
|
||||
return $query;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses the statements defined by the tokens list.
|
||||
*
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param TokensList $list the list of tokens to be parsed
|
||||
*
|
||||
* @return void
|
||||
*
|
||||
* @throws Exceptions\ParserException
|
||||
*/
|
||||
public function parse(Parser $parser, TokensList $list)
|
||||
{
|
||||
/**
|
||||
* Array containing all list of clauses parsed.
|
||||
* This is used to check for duplicates.
|
||||
*/
|
||||
$parsedClauses = [];
|
||||
|
||||
// This may be corrected by the parser.
|
||||
$this->first = $list->idx;
|
||||
|
||||
/**
|
||||
* Whether options were parsed or not.
|
||||
* For statements that do not have any options this is set to `true` by
|
||||
* default.
|
||||
*/
|
||||
$parsedOptions = empty(static::$OPTIONS);
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Checking if this closing bracket is the pair for a bracket
|
||||
// outside the statement.
|
||||
if (($token->value === ')') && ($parser->brackets > 0)) {
|
||||
--$parser->brackets;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Only keywords are relevant here. Other parts of the query are
|
||||
// processed in the functions below.
|
||||
if ($token->type !== Token::TYPE_KEYWORD) {
|
||||
if (($token->type !== Token::TYPE_COMMENT) && ($token->type !== Token::TYPE_WHITESPACE)) {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Unions are parsed by the parser because they represent more than
|
||||
// one statement.
|
||||
if (
|
||||
($token->keyword === 'UNION') ||
|
||||
($token->keyword === 'UNION ALL') ||
|
||||
($token->keyword === 'UNION DISTINCT') ||
|
||||
($token->keyword === 'EXCEPT') ||
|
||||
($token->keyword === 'INTERSECT')
|
||||
) {
|
||||
break;
|
||||
}
|
||||
|
||||
$lastIdx = $list->idx;
|
||||
|
||||
// ON DUPLICATE KEY UPDATE ...
|
||||
// has to be parsed in parent statement (INSERT or REPLACE)
|
||||
// so look for it and break
|
||||
if ($this instanceof Statements\SelectStatement && $token->value === 'ON') {
|
||||
++$list->idx; // Skip ON
|
||||
|
||||
// look for ON DUPLICATE KEY UPDATE
|
||||
$first = $list->getNextOfType(Token::TYPE_KEYWORD);
|
||||
$second = $list->getNextOfType(Token::TYPE_KEYWORD);
|
||||
$third = $list->getNextOfType(Token::TYPE_KEYWORD);
|
||||
|
||||
if (
|
||||
$first && $second && $third
|
||||
&& $first->value === 'DUPLICATE'
|
||||
&& $second->value === 'KEY'
|
||||
&& $third->value === 'UPDATE'
|
||||
) {
|
||||
$list->idx = $lastIdx;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
$list->idx = $lastIdx;
|
||||
|
||||
/**
|
||||
* The name of the class that is used for parsing.
|
||||
*
|
||||
* @var Component
|
||||
*/
|
||||
$class = null;
|
||||
|
||||
/**
|
||||
* The name of the field where the result of the parsing is stored.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$field = null;
|
||||
|
||||
/**
|
||||
* Parser's options.
|
||||
*/
|
||||
$options = [];
|
||||
|
||||
// Looking for duplicated clauses.
|
||||
if (
|
||||
! empty(Parser::$KEYWORD_PARSERS[$token->value])
|
||||
|| ! empty(Parser::$STATEMENT_PARSERS[$token->value])
|
||||
) {
|
||||
if (! empty($parsedClauses[$token->value])) {
|
||||
$parser->error('This type of clause was previously parsed.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$parsedClauses[$token->value] = true;
|
||||
}
|
||||
|
||||
// Checking if this is the beginning of a clause.
|
||||
// Fix Issue #221: As `truncate` is not a keyword
|
||||
// but it might be the beginning of a statement of truncate,
|
||||
// so let the value use the keyword field for truncate type.
|
||||
$tokenValue = in_array($token->keyword, ['TRUNCATE']) ? $token->keyword : $token->value;
|
||||
if (! empty(Parser::$KEYWORD_PARSERS[$tokenValue]) && $list->idx < $list->count) {
|
||||
$class = Parser::$KEYWORD_PARSERS[$tokenValue]['class'];
|
||||
$field = Parser::$KEYWORD_PARSERS[$tokenValue]['field'];
|
||||
if (! empty(Parser::$KEYWORD_PARSERS[$tokenValue]['options'])) {
|
||||
$options = Parser::$KEYWORD_PARSERS[$tokenValue]['options'];
|
||||
}
|
||||
}
|
||||
|
||||
// Checking if this is the beginning of the statement.
|
||||
if (! empty(Parser::$STATEMENT_PARSERS[$token->keyword])) {
|
||||
if (
|
||||
! empty(static::$CLAUSES) // Undefined for some statements.
|
||||
&& empty(static::$CLAUSES[$token->value])
|
||||
) {
|
||||
// Some keywords (e.g. `SET`) may be the beginning of a
|
||||
// statement and a clause.
|
||||
// If such keyword was found and it cannot be a clause of
|
||||
// this statement it means it is a new statement, but no
|
||||
// delimiter was found between them.
|
||||
$parser->error(
|
||||
'A new statement was found, but no delimiter between it and the previous one.',
|
||||
$token
|
||||
);
|
||||
break;
|
||||
}
|
||||
|
||||
if (! $parsedOptions) {
|
||||
if (empty(static::$OPTIONS[$token->value])) {
|
||||
// Skipping keyword because if it is not a option.
|
||||
++$list->idx;
|
||||
}
|
||||
|
||||
$this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
$parsedOptions = true;
|
||||
}
|
||||
} elseif ($class === null) {
|
||||
if ($this instanceof Statements\SelectStatement && $token->value === 'WITH ROLLUP') {
|
||||
// Handle group options in Select statement
|
||||
// See Statements\SelectStatement::$GROUP_OPTIONS
|
||||
$this->group_options = OptionsArray::parse($parser, $list, static::$GROUP_OPTIONS);
|
||||
} elseif (
|
||||
$this instanceof Statements\SelectStatement
|
||||
&& ($token->value === 'FOR UPDATE'
|
||||
|| $token->value === 'LOCK IN SHARE MODE')
|
||||
) {
|
||||
// Handle special end options in Select statement
|
||||
// See Statements\SelectStatement::$END_OPTIONS
|
||||
$this->end_options = OptionsArray::parse($parser, $list, static::$END_OPTIONS);
|
||||
} elseif (
|
||||
$this instanceof Statements\SetStatement
|
||||
&& ($token->value === 'COLLATE'
|
||||
|| $token->value === 'DEFAULT')
|
||||
) {
|
||||
// Handle special end options in SET statement
|
||||
// See Statements\SetStatement::$END_OPTIONS
|
||||
$this->end_options = OptionsArray::parse($parser, $list, static::$END_OPTIONS);
|
||||
} else {
|
||||
// There is no parser for this keyword and isn't the beginning
|
||||
// of a statement (so no options) either.
|
||||
$parser->error('Unrecognized keyword.', $token);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
$this->before($parser, $list, $token);
|
||||
|
||||
// Parsing this keyword.
|
||||
if ($class !== null) {
|
||||
// We can't parse keyword at the end of statement
|
||||
if ($list->idx >= $list->count) {
|
||||
$parser->error('Keyword at end of statement.', $token);
|
||||
continue;
|
||||
}
|
||||
|
||||
++$list->idx; // Skipping keyword or last option.
|
||||
$this->$field = $class::parse($parser, $list, $options);
|
||||
}
|
||||
|
||||
$this->after($parser, $list, $token);
|
||||
}
|
||||
|
||||
// This may be corrected by the parser.
|
||||
$this->last = --$list->idx; // Go back to last used token.
|
||||
}
|
||||
|
||||
/**
|
||||
* Function called before the token is processed.
|
||||
*
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param TokensList $list the list of tokens to be parsed
|
||||
* @param Token $token the token that is being parsed
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function before(Parser $parser, TokensList $list, Token $token)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Function called after the token was processed.
|
||||
*
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param TokensList $list the list of tokens to be parsed
|
||||
* @param Token $token the token that is being parsed
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function after(Parser $parser, TokensList $list, Token $token)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the clauses of this statement.
|
||||
*
|
||||
* @return array<string, array<int, int|string>>
|
||||
* @psalm-return array<string, array{non-empty-string, (1|2|3)}>
|
||||
*/
|
||||
public function getClauses()
|
||||
{
|
||||
return static::$CLAUSES;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the clause order of this statement as an array
|
||||
* with clause as key and index as value.
|
||||
*
|
||||
* @return array<string, int>
|
||||
*/
|
||||
public function getClauseOrder(): array
|
||||
{
|
||||
$clauses = [];
|
||||
foreach (array_keys($this->getClauses()) as $key) {
|
||||
if ($key === '_END_OPTIONS') {
|
||||
if (static::$END_OPTIONS !== []) {
|
||||
array_push($clauses, ...array_keys(static::$END_OPTIONS));
|
||||
}
|
||||
} else {
|
||||
$clauses[] = $key;
|
||||
}
|
||||
}
|
||||
|
||||
return array_flip($clauses);
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds the string representation of this statement.
|
||||
*
|
||||
* @see static::build
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function __toString()
|
||||
{
|
||||
return $this->build();
|
||||
}
|
||||
|
||||
/**
|
||||
* Validates the order of the clauses in parsed statement
|
||||
* Ideally this should be called after successfully
|
||||
* completing the parsing of each statement.
|
||||
*
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param TokensList $list the list of tokens to be parsed
|
||||
*
|
||||
* @return bool
|
||||
*
|
||||
* @throws Exceptions\ParserException
|
||||
*/
|
||||
public function validateClauseOrder($parser, $list)
|
||||
{
|
||||
$clauses = array_flip(array_keys($this->getClauses()));
|
||||
|
||||
if (empty($clauses) || count($clauses) === 0) {
|
||||
return true;
|
||||
}
|
||||
|
||||
$minIdx = -1;
|
||||
|
||||
/**
|
||||
* For tracking JOIN clauses in a query
|
||||
* = 0 - JOIN not found till now
|
||||
* > 0 - Index of first JOIN clause in the statement.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$minJoin = 0;
|
||||
|
||||
/**
|
||||
* For tracking JOIN clauses in a query
|
||||
* = 0 - JOIN not found till now
|
||||
* > 0 - Index of last JOIN clause
|
||||
* (which appears together with other JOINs)
|
||||
* in the statement.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$maxJoin = 0;
|
||||
|
||||
$error = 0;
|
||||
$lastIdx = 0;
|
||||
foreach ($clauses as $clauseType => $index) {
|
||||
$clauseStartIdx = Utils\Query::getClauseStartOffset($this, $list, $clauseType);
|
||||
|
||||
if (
|
||||
$clauseStartIdx !== -1
|
||||
&& $this instanceof Statements\SelectStatement
|
||||
&& ($clauseType === 'FORCE'
|
||||
|| $clauseType === 'IGNORE'
|
||||
|| $clauseType === 'USE')
|
||||
) {
|
||||
// TODO: ordering of clauses in a SELECT statement with
|
||||
// Index hints is not supported
|
||||
return true;
|
||||
}
|
||||
|
||||
// Handle ordering of Multiple Joins in a query
|
||||
if ($clauseStartIdx !== -1) {
|
||||
if ($minJoin === 0 && stripos($clauseType, 'JOIN')) {
|
||||
// First JOIN clause is detected
|
||||
$minJoin = $maxJoin = $clauseStartIdx;
|
||||
} elseif ($minJoin !== 0 && ! stripos($clauseType, 'JOIN')) {
|
||||
// After a previous JOIN clause, a non-JOIN clause has been detected
|
||||
$maxJoin = $lastIdx;
|
||||
} elseif ($maxJoin < $clauseStartIdx && stripos($clauseType, 'JOIN')) {
|
||||
$error = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if ($clauseStartIdx !== -1 && $clauseStartIdx < $minIdx) {
|
||||
if ($minJoin === 0 || $error === 1) {
|
||||
$token = $list->tokens[$clauseStartIdx];
|
||||
$parser->error('Unexpected ordering of clauses.', $token);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
$minIdx = $clauseStartIdx;
|
||||
} elseif ($clauseStartIdx !== -1) {
|
||||
$minIdx = $clauseStartIdx;
|
||||
}
|
||||
|
||||
$lastIdx = $clauseStartIdx !== -1 ? $clauseStartIdx : $lastIdx;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
+162
@@ -0,0 +1,162 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\AlterOperation;
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function implode;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `ALTER` statement.
|
||||
*/
|
||||
class AlterStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Table affected.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $table;
|
||||
|
||||
/**
|
||||
* Column affected by this statement.
|
||||
*
|
||||
* @var AlterOperation[]|null
|
||||
*/
|
||||
public $altered = [];
|
||||
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'ONLINE' => 1,
|
||||
'OFFLINE' => 1,
|
||||
'IGNORE' => 2,
|
||||
// `DEFINER` is also used for `ALTER EVENT`
|
||||
'DEFINER' => [
|
||||
2,
|
||||
'expr=',
|
||||
],
|
||||
'DATABASE' => 3,
|
||||
'EVENT' => 3,
|
||||
'FUNCTION' => 3,
|
||||
'PROCEDURE' => 3,
|
||||
'SERVER' => 3,
|
||||
'TABLE' => 3,
|
||||
'TABLESPACE' => 3,
|
||||
'USER' => 3,
|
||||
'VIEW' => 3,
|
||||
];
|
||||
|
||||
/**
|
||||
* @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 `ALTER`.
|
||||
$parsedOptions = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
if ($parsedOptions->isEmpty()) {
|
||||
$parser->error('Unrecognized alter operation.', $list->tokens[$list->idx]);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$this->options = $parsedOptions;
|
||||
++$list->idx;
|
||||
|
||||
// Parsing affected table.
|
||||
$this->table = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
[
|
||||
'parseField' => 'table',
|
||||
'breakOnAlias' => true,
|
||||
]
|
||||
);
|
||||
++$list->idx; // Skipping field.
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 -----------------[ alter operation ]-----------------> 1
|
||||
*
|
||||
* 1 -------------------------[ , ]-----------------------> 0
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
$options = [];
|
||||
if ($this->options->has('DATABASE')) {
|
||||
$options = AlterOperation::$DB_OPTIONS;
|
||||
} elseif ($this->options->has('TABLE')) {
|
||||
$options = AlterOperation::$TABLE_OPTIONS;
|
||||
} elseif ($this->options->has('VIEW')) {
|
||||
$options = AlterOperation::$VIEW_OPTIONS;
|
||||
} elseif ($this->options->has('USER')) {
|
||||
$options = AlterOperation::$USER_OPTIONS;
|
||||
} elseif ($this->options->has('EVENT')) {
|
||||
$options = AlterOperation::$EVENT_OPTIONS;
|
||||
} elseif ($this->options->has('FUNCTION') || $this->options->has('PROCEDURE')) {
|
||||
$options = AlterOperation::$ROUTINE_OPTIONS;
|
||||
}
|
||||
|
||||
$this->altered[] = AlterOperation::parse($parser, $list, $options);
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === ',')) {
|
||||
$state = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$tmp = [];
|
||||
foreach ($this->altered as $altered) {
|
||||
$tmp[] = $altered::build($altered);
|
||||
}
|
||||
|
||||
return trim(
|
||||
'ALTER ' . OptionsArray::build($this->options)
|
||||
. ' ' . Expression::build($this->table)
|
||||
. ' ' . implode(', ', $tmp)
|
||||
);
|
||||
}
|
||||
}
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
|
||||
/**
|
||||
* `ANALYZE` statement.
|
||||
*
|
||||
* ANALYZE [NO_WRITE_TO_BINLOG | LOCAL] TABLE
|
||||
* tbl_name [, tbl_name] ...
|
||||
*/
|
||||
class AnalyzeStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'TABLE' => 1,
|
||||
|
||||
'NO_WRITE_TO_BINLOG' => 2,
|
||||
'LOCAL' => 3,
|
||||
];
|
||||
|
||||
/**
|
||||
* Analyzed tables.
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $tables;
|
||||
}
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
/**
|
||||
* `BACKUP` statement.
|
||||
*
|
||||
* BACKUP TABLE tbl_name [, tbl_name] ... TO '/path/to/backup/directory'
|
||||
*/
|
||||
class BackupStatement extends MaintenanceStatement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'TABLE' => 1,
|
||||
|
||||
'NO_WRITE_TO_BINLOG' => 2,
|
||||
'LOCAL' => 3,
|
||||
|
||||
'TO' => [
|
||||
4,
|
||||
'var',
|
||||
],
|
||||
];
|
||||
}
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\FunctionCall;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
|
||||
use function implode;
|
||||
|
||||
/**
|
||||
* `CALL` statement.
|
||||
*
|
||||
* CALL sp_name([parameter[,...]])
|
||||
*
|
||||
* or
|
||||
*
|
||||
* CALL sp_name[()]
|
||||
*/
|
||||
class CallStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* The name of the function and its parameters.
|
||||
*
|
||||
* @var FunctionCall|null
|
||||
*/
|
||||
public $call;
|
||||
|
||||
/**
|
||||
* Build statement for CALL.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
return 'CALL ' . $this->call->name . '('
|
||||
. ($this->call->parameters ? implode(',', $this->call->parameters->raw) : '') . ')';
|
||||
}
|
||||
}
|
||||
+30
@@ -0,0 +1,30 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
/**
|
||||
* `CHECK` statement.
|
||||
*
|
||||
* CHECK TABLE tbl_name [, tbl_name] ... [option] ...
|
||||
*/
|
||||
class CheckStatement extends MaintenanceStatement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'TABLE' => 1,
|
||||
|
||||
'FOR UPGRADE' => 2,
|
||||
'QUICK' => 3,
|
||||
'FAST' => 4,
|
||||
'MEDIUM' => 5,
|
||||
'EXTENDED' => 6,
|
||||
'CHANGED' => 7,
|
||||
];
|
||||
}
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
/**
|
||||
* `CHECKSUM` statement.
|
||||
*
|
||||
* CHECKSUM TABLE tbl_name [, tbl_name] ... [ QUICK | EXTENDED ]
|
||||
*/
|
||||
class ChecksumStatement extends MaintenanceStatement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'TABLE' => 1,
|
||||
|
||||
'QUICK' => 2,
|
||||
'EXTENDED' => 3,
|
||||
];
|
||||
}
|
||||
+805
@@ -0,0 +1,805 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
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;
|
||||
|
||||
use function is_array;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `CREATE` statement.
|
||||
*/
|
||||
class CreateStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `CREATE` statements.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
// CREATE TABLE
|
||||
'TEMPORARY' => 1,
|
||||
|
||||
// CREATE VIEW
|
||||
'OR REPLACE' => 2,
|
||||
'ALGORITHM' => [
|
||||
3,
|
||||
'var=',
|
||||
],
|
||||
// `DEFINER` is also used for `CREATE FUNCTION / PROCEDURE`
|
||||
'DEFINER' => [
|
||||
4,
|
||||
'expr=',
|
||||
],
|
||||
// Used in `CREATE VIEW`
|
||||
'SQL SECURITY' => [
|
||||
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,
|
||||
'SCHEMA' => 6,
|
||||
|
||||
// CREATE TABLE
|
||||
'IF NOT EXISTS' => 7,
|
||||
];
|
||||
|
||||
/**
|
||||
* All database options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $DB_OPTIONS = [
|
||||
'CHARACTER SET' => [
|
||||
1,
|
||||
'var=',
|
||||
],
|
||||
'CHARSET' => [
|
||||
1,
|
||||
'var=',
|
||||
],
|
||||
'DEFAULT CHARACTER SET' => [
|
||||
1,
|
||||
'var=',
|
||||
],
|
||||
'DEFAULT CHARSET' => [
|
||||
1,
|
||||
'var=',
|
||||
],
|
||||
'DEFAULT COLLATE' => [
|
||||
2,
|
||||
'var=',
|
||||
],
|
||||
'COLLATE' => [
|
||||
2,
|
||||
'var=',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* All table options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $TABLE_OPTIONS = [
|
||||
'ENGINE' => [
|
||||
1,
|
||||
'var=',
|
||||
],
|
||||
'AUTO_INCREMENT' => [
|
||||
2,
|
||||
'var=',
|
||||
],
|
||||
'AVG_ROW_LENGTH' => [
|
||||
3,
|
||||
'var',
|
||||
],
|
||||
'CHARACTER SET' => [
|
||||
4,
|
||||
'var=',
|
||||
],
|
||||
'CHARSET' => [
|
||||
4,
|
||||
'var=',
|
||||
],
|
||||
'DEFAULT CHARACTER SET' => [
|
||||
4,
|
||||
'var=',
|
||||
],
|
||||
'DEFAULT CHARSET' => [
|
||||
4,
|
||||
'var=',
|
||||
],
|
||||
'CHECKSUM' => [
|
||||
5,
|
||||
'var',
|
||||
],
|
||||
'DEFAULT COLLATE' => [
|
||||
6,
|
||||
'var=',
|
||||
],
|
||||
'COLLATE' => [
|
||||
6,
|
||||
'var=',
|
||||
],
|
||||
'COMMENT' => [
|
||||
7,
|
||||
'var=',
|
||||
],
|
||||
'CONNECTION' => [
|
||||
8,
|
||||
'var',
|
||||
],
|
||||
'DATA DIRECTORY' => [
|
||||
9,
|
||||
'var',
|
||||
],
|
||||
'DELAY_KEY_WRITE' => [
|
||||
10,
|
||||
'var',
|
||||
],
|
||||
'INDEX DIRECTORY' => [
|
||||
11,
|
||||
'var',
|
||||
],
|
||||
'INSERT_METHOD' => [
|
||||
12,
|
||||
'var',
|
||||
],
|
||||
'KEY_BLOCK_SIZE' => [
|
||||
13,
|
||||
'var',
|
||||
],
|
||||
'MAX_ROWS' => [
|
||||
14,
|
||||
'var',
|
||||
],
|
||||
'MIN_ROWS' => [
|
||||
15,
|
||||
'var',
|
||||
],
|
||||
'PACK_KEYS' => [
|
||||
16,
|
||||
'var',
|
||||
],
|
||||
'PASSWORD' => [
|
||||
17,
|
||||
'var',
|
||||
],
|
||||
'ROW_FORMAT' => [
|
||||
18,
|
||||
'var',
|
||||
],
|
||||
'TABLESPACE' => [
|
||||
19,
|
||||
'var',
|
||||
],
|
||||
'STORAGE' => [
|
||||
20,
|
||||
'var',
|
||||
],
|
||||
'UNION' => [
|
||||
21,
|
||||
'var',
|
||||
],
|
||||
'PAGE_COMPRESSED' => [
|
||||
22,
|
||||
'var',
|
||||
],
|
||||
'PAGE_COMPRESSION_LEVEL' => [
|
||||
23,
|
||||
'var',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* All function options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $FUNC_OPTIONS = [
|
||||
'NOT' => [
|
||||
2,
|
||||
'var',
|
||||
],
|
||||
'FUNCTION' => [
|
||||
3,
|
||||
'var=',
|
||||
],
|
||||
'PROCEDURE' => [
|
||||
3,
|
||||
'var=',
|
||||
],
|
||||
'CONTAINS SQL' => 4,
|
||||
'NO SQL' => 4,
|
||||
'READS SQL DATA' => 4,
|
||||
'MODIFIES SQL DATA' => 4,
|
||||
'SQL SECURITY' => [
|
||||
6,
|
||||
'var',
|
||||
],
|
||||
'LANGUAGE' => [
|
||||
7,
|
||||
'var',
|
||||
],
|
||||
'COMMENT' => [
|
||||
8,
|
||||
'var',
|
||||
],
|
||||
|
||||
'CREATE' => 1,
|
||||
'DETERMINISTIC' => 2,
|
||||
];
|
||||
|
||||
/**
|
||||
* All trigger options.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $TRIGGER_OPTIONS = [
|
||||
'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|null
|
||||
*/
|
||||
public $name;
|
||||
|
||||
/**
|
||||
* The options of the entity (table, procedure, function, etc.).
|
||||
*
|
||||
* Used by `CREATE TABLE`, `CREATE FUNCTION` and `CREATE PROCEDURE`.
|
||||
*
|
||||
* @see static::$TABLE_OPTIONS
|
||||
* @see static::$FUNC_OPTIONS
|
||||
* @see static::$TRIGGER_OPTIONS
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
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|null
|
||||
*/
|
||||
public $fields;
|
||||
|
||||
/**
|
||||
* If `CREATE TABLE WITH`.
|
||||
* If `CREATE TABLE AS WITH`.
|
||||
* If `CREATE VIEW AS WITH`.
|
||||
*
|
||||
* Used by `CREATE TABLE`, `CREATE VIEW`
|
||||
*
|
||||
* @var WithStatement|null
|
||||
*/
|
||||
public $with;
|
||||
|
||||
/**
|
||||
* If `CREATE TABLE ... SELECT`.
|
||||
* If `CREATE VIEW AS ` ... SELECT`.
|
||||
*
|
||||
* Used by `CREATE TABLE`, `CREATE VIEW`
|
||||
*
|
||||
* @var SelectStatement|null
|
||||
*/
|
||||
public $select;
|
||||
|
||||
/**
|
||||
* If `CREATE TABLE ... LIKE`.
|
||||
*
|
||||
* Used by `CREATE TABLE`
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $like;
|
||||
|
||||
/**
|
||||
* Expression used for partitioning.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $partitionBy;
|
||||
|
||||
/**
|
||||
* The number of partitions.
|
||||
*
|
||||
* @var int|null
|
||||
*/
|
||||
public $partitionsNum;
|
||||
|
||||
/**
|
||||
* Expression used for subpartitioning.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $subpartitionBy;
|
||||
|
||||
/**
|
||||
* The number of subpartitions.
|
||||
*
|
||||
* @var int|null
|
||||
*/
|
||||
public $subpartitionsNum;
|
||||
|
||||
/**
|
||||
* The partition of the new table.
|
||||
*
|
||||
* @var PartitionDefinition[]|null
|
||||
*/
|
||||
public $partitions;
|
||||
|
||||
/**
|
||||
* If `CREATE TRIGGER` the name of the table.
|
||||
*
|
||||
* Used by `CREATE TRIGGER`.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $table;
|
||||
|
||||
/**
|
||||
* The return data type of this routine.
|
||||
*
|
||||
* Used by `CREATE FUNCTION`.
|
||||
*
|
||||
* @var DataType|null
|
||||
*/
|
||||
public $return;
|
||||
|
||||
/**
|
||||
* The parameters of this routine.
|
||||
*
|
||||
* Used by `CREATE FUNCTION` and `CREATE PROCEDURE`.
|
||||
*
|
||||
* @var ParameterDefinition[]|null
|
||||
*/
|
||||
public $parameters;
|
||||
|
||||
/**
|
||||
* The body of this function or procedure.
|
||||
* For views, it is the select statement that creates the view.
|
||||
* Used by `CREATE FUNCTION`, `CREATE PROCEDURE` and `CREATE VIEW`.
|
||||
*
|
||||
* @var Token[]|string
|
||||
*/
|
||||
public $body = [];
|
||||
|
||||
/**
|
||||
* @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') || $this->options->has('SCHEMA')) {
|
||||
return 'CREATE '
|
||||
. OptionsArray::build($this->options) . ' '
|
||||
. Expression::build($this->name) . ' '
|
||||
. OptionsArray::build($this->entityOptions);
|
||||
}
|
||||
|
||||
if ($this->options->has('TABLE')) {
|
||||
if ($this->select !== null) {
|
||||
return 'CREATE '
|
||||
. OptionsArray::build($this->options) . ' '
|
||||
. Expression::build($this->name) . ' '
|
||||
. $this->select->build();
|
||||
}
|
||||
|
||||
if ($this->like !== null) {
|
||||
return 'CREATE '
|
||||
. OptionsArray::build($this->options) . ' '
|
||||
. Expression::build($this->name) . ' LIKE '
|
||||
. Expression::build($this->like);
|
||||
}
|
||||
|
||||
if ($this->with !== null) {
|
||||
return 'CREATE '
|
||||
. OptionsArray::build($this->options) . ' '
|
||||
. Expression::build($this->name) . ' '
|
||||
. $this->with->build();
|
||||
}
|
||||
|
||||
$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')) {
|
||||
$builtStatement = '';
|
||||
if ($this->select !== null) {
|
||||
$builtStatement = $this->select->build();
|
||||
} elseif ($this->with !== null) {
|
||||
$builtStatement = $this->with->build();
|
||||
}
|
||||
|
||||
return 'CREATE '
|
||||
. OptionsArray::build($this->options) . ' '
|
||||
. Expression::build($this->name) . ' '
|
||||
. $fields . ' AS ' . $builtStatement
|
||||
. (! empty($this->body) ? 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 . ' ' . OptionsArray::build($this->entityOptions) . ' '
|
||||
. 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.
|
||||
|
||||
$isDatabase = $this->options->has('DATABASE') || $this->options->has('SCHEMA');
|
||||
$fieldName = $isDatabase ? 'database' : 'table';
|
||||
|
||||
// Parsing the field name.
|
||||
$this->name = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
[
|
||||
'parseField' => $fieldName,
|
||||
'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.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
$nextidx = $list->idx + 1;
|
||||
while ($nextidx < $list->count && $list->tokens[$nextidx]->type === Token::TYPE_WHITESPACE) {
|
||||
++$nextidx;
|
||||
}
|
||||
|
||||
if ($isDatabase) {
|
||||
$this->entityOptions = OptionsArray::parse($parser, $list, static::$DB_OPTIONS);
|
||||
} elseif ($this->options->has('TABLE')) {
|
||||
if (($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'SELECT')) {
|
||||
/* CREATE TABLE ... SELECT */
|
||||
$this->select = new SelectStatement($parser, $list);
|
||||
} elseif ($token->type === Token::TYPE_KEYWORD && ($token->keyword === 'WITH')) {
|
||||
/* CREATE TABLE WITH */
|
||||
$this->with = new WithStatement($parser, $list);
|
||||
} elseif (
|
||||
($token->type === Token::TYPE_KEYWORD) && ($token->keyword === 'AS')
|
||||
&& ($list->tokens[$nextidx]->type === Token::TYPE_KEYWORD)
|
||||
) {
|
||||
if ($list->tokens[$nextidx]->value === 'SELECT') {
|
||||
/* CREATE TABLE ... AS SELECT */
|
||||
$list->idx = $nextidx;
|
||||
$this->select = new SelectStatement($parser, $list);
|
||||
} elseif ($list->tokens[$nextidx]->value === 'WITH') {
|
||||
/* CREATE TABLE WITH */
|
||||
$list->idx = $nextidx;
|
||||
$this->with = new WithStatement($parser, $list);
|
||||
}
|
||||
} elseif ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'LIKE') {
|
||||
/* CREATE TABLE `new_tbl` LIKE 'orig_tbl' */
|
||||
$list->idx = $nextidx;
|
||||
$this->like = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
[
|
||||
'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]);
|
||||
}
|
||||
} else {
|
||||
$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.
|
||||
*/
|
||||
$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) {
|
||||
if ($token->value === '(') {
|
||||
// This is used instead of `++$brackets` because,
|
||||
// initially, `$brackets` is `false` cannot be
|
||||
// incremented.
|
||||
$brackets += 1;
|
||||
} elseif ($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(
|
||||
$parser,
|
||||
$list,
|
||||
['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')) {
|
||||
$prevToken = $token;
|
||||
$token = $list->getNextOfType(Token::TYPE_KEYWORD);
|
||||
if ($token === null || $token->keyword !== 'RETURNS') {
|
||||
$parser->error('A "RETURNS" keyword was expected.', $token ?? $prevToken);
|
||||
} 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];
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
$this->body[] = $token;
|
||||
}
|
||||
} elseif ($this->options->has('VIEW')) {
|
||||
/** @var Token $token */
|
||||
$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 SELECT expression if the view started with it.
|
||||
if (
|
||||
$token->type === Token::TYPE_KEYWORD
|
||||
&& $token->keyword === 'AS'
|
||||
&& $list->tokens[$nextidx]->type === Token::TYPE_KEYWORD
|
||||
) {
|
||||
if ($list->tokens[$nextidx]->value === 'SELECT') {
|
||||
$list->idx = $nextidx;
|
||||
$this->select = new SelectStatement($parser, $list);
|
||||
++$list->idx; // Skipping last token from the select.
|
||||
} elseif ($list->tokens[$nextidx]->value === 'WITH') {
|
||||
++$list->idx;
|
||||
$this->with = new WithStatement($parser, $list);
|
||||
}
|
||||
}
|
||||
|
||||
// Parsing all other tokens
|
||||
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,
|
||||
[
|
||||
'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];
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
$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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+374
@@ -0,0 +1,374 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\ArrayObj;
|
||||
use PhpMyAdmin\SqlParser\Components\Condition;
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Components\ExpressionArray;
|
||||
use PhpMyAdmin\SqlParser\Components\JoinKeyword;
|
||||
use PhpMyAdmin\SqlParser\Components\Limit;
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Components\OrderKeyword;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function count;
|
||||
use function stripos;
|
||||
use function strlen;
|
||||
|
||||
/**
|
||||
* `DELETE` statement.
|
||||
*
|
||||
* DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM tbl_name
|
||||
* [PARTITION (partition_name,...)]
|
||||
* [WHERE where_condition]
|
||||
* [ORDER BY ...]
|
||||
* [LIMIT row_count]
|
||||
*
|
||||
* Multi-table syntax
|
||||
*
|
||||
* DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
|
||||
* tbl_name[.*] [, tbl_name[.*]] ...
|
||||
* FROM table_references
|
||||
* [WHERE where_condition]
|
||||
*
|
||||
* OR
|
||||
*
|
||||
* DELETE [LOW_PRIORITY] [QUICK] [IGNORE]
|
||||
* FROM tbl_name[.*] [, tbl_name[.*]] ...
|
||||
* USING table_references
|
||||
* [WHERE where_condition]
|
||||
*/
|
||||
class DeleteStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `DELETE` statements.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'LOW_PRIORITY' => 1,
|
||||
'QUICK' => 2,
|
||||
'IGNORE' => 3,
|
||||
];
|
||||
|
||||
/**
|
||||
* The clauses of this statement, in order.
|
||||
*
|
||||
* @see Statement::$CLAUSES
|
||||
*
|
||||
* @var array<string, array<int, int|string>>
|
||||
* @psalm-var array<string, array{non-empty-string, (1|2|3)}>
|
||||
*/
|
||||
public static $CLAUSES = [
|
||||
'DELETE' => [
|
||||
'DELETE',
|
||||
2,
|
||||
],
|
||||
// Used for options.
|
||||
'_OPTIONS' => [
|
||||
'_OPTIONS',
|
||||
1,
|
||||
],
|
||||
'FROM' => [
|
||||
'FROM',
|
||||
3,
|
||||
],
|
||||
'PARTITION' => [
|
||||
'PARTITION',
|
||||
3,
|
||||
],
|
||||
'USING' => [
|
||||
'USING',
|
||||
3,
|
||||
],
|
||||
'WHERE' => [
|
||||
'WHERE',
|
||||
3,
|
||||
],
|
||||
'ORDER BY' => [
|
||||
'ORDER BY',
|
||||
3,
|
||||
],
|
||||
'LIMIT' => [
|
||||
'LIMIT',
|
||||
3,
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* Table(s) used as sources for this statement.
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $from;
|
||||
|
||||
/**
|
||||
* Joins.
|
||||
*
|
||||
* @var JoinKeyword[]|null
|
||||
*/
|
||||
public $join;
|
||||
|
||||
/**
|
||||
* Tables used as sources for this statement.
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $using;
|
||||
|
||||
/**
|
||||
* Columns used in this statement.
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $columns;
|
||||
|
||||
/**
|
||||
* Partitions used as source for this statement.
|
||||
*
|
||||
* @var ArrayObj|null
|
||||
*/
|
||||
public $partition;
|
||||
|
||||
/**
|
||||
* Conditions used for filtering each row of the result set.
|
||||
*
|
||||
* @var Condition[]|null
|
||||
*/
|
||||
public $where;
|
||||
|
||||
/**
|
||||
* Specifies the order of the rows in the result set.
|
||||
*
|
||||
* @var OrderKeyword[]|null
|
||||
*/
|
||||
public $order;
|
||||
|
||||
/**
|
||||
* Conditions used for limiting the size of the result set.
|
||||
*
|
||||
* @var Limit|null
|
||||
*/
|
||||
public $limit;
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$ret = 'DELETE ' . OptionsArray::build($this->options);
|
||||
|
||||
if ($this->columns !== null && count($this->columns) > 0) {
|
||||
$ret .= ' ' . ExpressionArray::build($this->columns);
|
||||
}
|
||||
|
||||
if ($this->from !== null && count($this->from) > 0) {
|
||||
$ret .= ' FROM ' . ExpressionArray::build($this->from);
|
||||
}
|
||||
|
||||
if ($this->join !== null && count($this->join) > 0) {
|
||||
$ret .= ' ' . JoinKeyword::build($this->join);
|
||||
}
|
||||
|
||||
if ($this->using !== null && count($this->using) > 0) {
|
||||
$ret .= ' USING ' . ExpressionArray::build($this->using);
|
||||
}
|
||||
|
||||
if ($this->where !== null && count($this->where) > 0) {
|
||||
$ret .= ' WHERE ' . Condition::build($this->where);
|
||||
}
|
||||
|
||||
if ($this->order !== null && count($this->order) > 0) {
|
||||
$ret .= ' ORDER BY ' . ExpressionArray::build($this->order);
|
||||
}
|
||||
|
||||
if ($this->limit !== null && strlen((string) $this->limit) > 0) {
|
||||
$ret .= ' LIMIT ' . Limit::build($this->limit);
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @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 `DELETE`.
|
||||
|
||||
// parse any options if provided
|
||||
$this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
++$list->idx;
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------------------------[ FROM ]----------------------------------> 2
|
||||
* 0 ------------------------------[ table[.*] ]--------------------------------> 1
|
||||
* 1 ---------------------------------[ FROM ]----------------------------------> 2
|
||||
* 2 --------------------------------[ USING ]----------------------------------> 3
|
||||
* 2 --------------------------------[ WHERE ]----------------------------------> 4
|
||||
* 2 --------------------------------[ ORDER ]----------------------------------> 5
|
||||
* 2 --------------------------------[ LIMIT ]----------------------------------> 6
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
/**
|
||||
* If the query is multi-table or not.
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
$multiTable = false;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if ($token->keyword !== 'FROM') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
++$list->idx; // Skip 'FROM'
|
||||
$this->from = ExpressionArray::parse($parser, $list);
|
||||
|
||||
$state = 2;
|
||||
} else {
|
||||
$this->columns = ExpressionArray::parse($parser, $list);
|
||||
$state = 1;
|
||||
}
|
||||
} elseif ($state === 1) {
|
||||
if ($token->type !== Token::TYPE_KEYWORD) {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->keyword !== 'FROM') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
++$list->idx; // Skip 'FROM'
|
||||
$this->from = ExpressionArray::parse($parser, $list);
|
||||
|
||||
$state = 2;
|
||||
} elseif ($state === 2) {
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if (stripos($token->keyword, 'JOIN') !== false) {
|
||||
++$list->idx;
|
||||
$this->join = JoinKeyword::parse($parser, $list);
|
||||
|
||||
// remain in state = 2
|
||||
} else {
|
||||
switch ($token->keyword) {
|
||||
case 'USING':
|
||||
++$list->idx; // Skip 'USING'
|
||||
$this->using = ExpressionArray::parse($parser, $list);
|
||||
$state = 3;
|
||||
|
||||
$multiTable = true;
|
||||
break;
|
||||
case 'WHERE':
|
||||
++$list->idx; // Skip 'WHERE'
|
||||
$this->where = Condition::parse($parser, $list);
|
||||
$state = 4;
|
||||
break;
|
||||
case 'ORDER BY':
|
||||
++$list->idx; // Skip 'ORDER BY'
|
||||
$this->order = OrderKeyword::parse($parser, $list);
|
||||
$state = 5;
|
||||
break;
|
||||
case 'LIMIT':
|
||||
++$list->idx; // Skip 'LIMIT'
|
||||
$this->limit = Limit::parse($parser, $list);
|
||||
$state = 6;
|
||||
break;
|
||||
default:
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
} elseif ($state === 3) {
|
||||
if ($token->type !== Token::TYPE_KEYWORD) {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->keyword !== 'WHERE') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
++$list->idx; // Skip 'WHERE'
|
||||
$this->where = Condition::parse($parser, $list);
|
||||
$state = 4;
|
||||
} elseif ($state === 4) {
|
||||
if ($multiTable === true && $token->type === Token::TYPE_KEYWORD) {
|
||||
$parser->error('This type of clause is not valid in Multi-table queries.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
switch ($token->keyword) {
|
||||
case 'ORDER BY':
|
||||
++$list->idx; // Skip 'ORDER BY'
|
||||
$this->order = OrderKeyword::parse($parser, $list);
|
||||
$state = 5;
|
||||
break;
|
||||
case 'LIMIT':
|
||||
++$list->idx; // Skip 'LIMIT'
|
||||
$this->limit = Limit::parse($parser, $list);
|
||||
$state = 6;
|
||||
break;
|
||||
default:
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break 2;
|
||||
}
|
||||
}
|
||||
} elseif ($state === 5) {
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if ($token->keyword !== 'LIMIT') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
++$list->idx; // Skip 'LIMIT'
|
||||
$this->limit = Limit::parse($parser, $list);
|
||||
$state = 6;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($state >= 2) {
|
||||
foreach ($this->from as $fromExpr) {
|
||||
$fromExpr->database = $fromExpr->table;
|
||||
$fromExpr->table = $fromExpr->column;
|
||||
$fromExpr->column = null;
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
}
|
||||
}
|
||||
+82
@@ -0,0 +1,82 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
|
||||
/**
|
||||
* `DROP` statement.
|
||||
*/
|
||||
class DropStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'DATABASE' => 1,
|
||||
'EVENT' => 1,
|
||||
'FUNCTION' => 1,
|
||||
'INDEX' => 1,
|
||||
'LOGFILE' => 1,
|
||||
'PROCEDURE' => 1,
|
||||
'SCHEMA' => 1,
|
||||
'SERVER' => 1,
|
||||
'TABLE' => 1,
|
||||
'VIEW' => 1,
|
||||
'TABLESPACE' => 1,
|
||||
'TRIGGER' => 1,
|
||||
'USER' => 1,
|
||||
|
||||
'TEMPORARY' => 2,
|
||||
'IF EXISTS' => 3,
|
||||
];
|
||||
|
||||
/**
|
||||
* The clauses of this statement, in order.
|
||||
*
|
||||
* @see Statement::$CLAUSES
|
||||
*
|
||||
* @var array<string, array<int, int|string>>
|
||||
* @psalm-var array<string, array{non-empty-string, (1|2|3)}>
|
||||
*/
|
||||
public static $CLAUSES = [
|
||||
'DROP' => [
|
||||
'DROP',
|
||||
2,
|
||||
],
|
||||
// Used for options.
|
||||
'_OPTIONS' => [
|
||||
'_OPTIONS',
|
||||
1,
|
||||
],
|
||||
// Used for select expressions.
|
||||
'DROP_' => [
|
||||
'DROP',
|
||||
1,
|
||||
],
|
||||
'ON' => [
|
||||
'ON',
|
||||
3,
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* Dropped elements.
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $fields;
|
||||
|
||||
/**
|
||||
* Table of the dropped index.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $table;
|
||||
}
|
||||
+286
@@ -0,0 +1,286 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function array_slice;
|
||||
use function count;
|
||||
|
||||
/**
|
||||
* `EXPLAIN` statement.
|
||||
*/
|
||||
class ExplainStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `EXPLAIN` statements.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
|
||||
'EXTENDED' => 1,
|
||||
'PARTITIONS' => 1,
|
||||
'FORMAT' => [
|
||||
1,
|
||||
'var',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* The parser of the statement to be explained
|
||||
*
|
||||
* @var Parser|null
|
||||
*/
|
||||
public $bodyParser = null;
|
||||
|
||||
/**
|
||||
* The statement alias, could be any of the following:
|
||||
* - {EXPLAIN | DESCRIBE | DESC}
|
||||
* - {EXPLAIN | DESCRIBE | DESC} ANALYZE
|
||||
* - ANALYZE
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $statementAlias;
|
||||
|
||||
/**
|
||||
* The connection identifier, if used.
|
||||
*
|
||||
* @var int|null
|
||||
*/
|
||||
public $connectionId = null;
|
||||
|
||||
/**
|
||||
* The explained database for the table's name, if used.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $explainedDatabase = null;
|
||||
|
||||
/**
|
||||
* The explained table's name, if used.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $explainedTable = null;
|
||||
|
||||
/**
|
||||
* The explained column's name, if used.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $explainedColumn = null;
|
||||
|
||||
/**
|
||||
* @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)
|
||||
{
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 -------------------[ EXPLAIN/EXPLAIN ANALYZE/ANALYZE ]-----------------------> 1
|
||||
*
|
||||
* 0 ------------------------[ EXPLAIN/DESC/DESCRIBE ]----------------------------> 3
|
||||
*
|
||||
* 1 ------------------------------[ OPTIONS ]------------------------------------> 2
|
||||
*
|
||||
* 2 --------------[ tablename / STATEMENT / FOR CONNECTION ]---------------------> 2
|
||||
*
|
||||
* 3 -----------------------------[ tablename ]-----------------------------------> 3
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
/**
|
||||
* To Differentiate between ANALYZE / EXPLAIN / EXPLAIN ANALYZE
|
||||
* 0 -> ANALYZE ( used by mariaDB https://mariadb.com/kb/en/analyze-statement)
|
||||
* 1 -> {EXPLAIN | DESCRIBE | DESC}
|
||||
* 2 -> {EXPLAIN | DESCRIBE | DESC} ANALYZE
|
||||
*/
|
||||
$miniState = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
--$list->idx; // Back up one token, no real reasons to document
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if ($token->type === Token::TYPE_WHITESPACE || $token->type === Token::TYPE_COMMENT) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->keyword === 'ANALYZE' && $miniState === 0) {
|
||||
$state = 1;
|
||||
$this->statementAlias = 'ANALYZE';
|
||||
} elseif (
|
||||
$token->keyword === 'EXPLAIN'
|
||||
|| $token->keyword === 'DESC'
|
||||
|| $token->keyword === 'DESCRIBE'
|
||||
) {
|
||||
$this->statementAlias = $token->keyword;
|
||||
|
||||
$lastIdx = $list->idx;
|
||||
$list->idx++; // Ignore the current token
|
||||
$nextKeyword = $list->getNextOfType(Token::TYPE_KEYWORD);
|
||||
$list->idx = $lastIdx;
|
||||
|
||||
// There is no other keyword, we must be describing a table
|
||||
if ($nextKeyword === null) {
|
||||
$state = 3;
|
||||
continue;
|
||||
}
|
||||
|
||||
$miniState = 1;
|
||||
|
||||
$lastIdx = $list->idx;
|
||||
$nextKeyword = $list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'ANALYZE');
|
||||
if ($nextKeyword && $nextKeyword->keyword !== null) {
|
||||
$miniState = 2;
|
||||
$this->statementAlias .= ' ANALYZE';
|
||||
} else {
|
||||
$list->idx = $lastIdx;
|
||||
}
|
||||
|
||||
$state = 1;
|
||||
}
|
||||
} elseif ($state === 1) {
|
||||
// Parsing options.
|
||||
$this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
$state = 2;
|
||||
} elseif ($state === 2) {
|
||||
$currIdx = $list->idx;
|
||||
$list->idx++; // Ignore the current token
|
||||
$nextToken = $list->getNext();
|
||||
$list->idx = $currIdx;
|
||||
|
||||
if ($token->keyword === 'FOR' && $nextToken->keyword === 'CONNECTION') {
|
||||
$list->idx++; // Ignore the current token
|
||||
$list->getNext(); // CONNECTION
|
||||
$nextToken = $list->getNext(); // Identifier
|
||||
$this->connectionId = $nextToken->value;
|
||||
break;
|
||||
}
|
||||
|
||||
if (
|
||||
$token->keyword !== 'SELECT'
|
||||
&& $token->keyword !== 'TABLE'
|
||||
&& $token->keyword !== 'INSERT'
|
||||
&& $token->keyword !== 'REPLACE'
|
||||
&& $token->keyword !== 'UPDATE'
|
||||
&& $token->keyword !== 'DELETE'
|
||||
) {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
// Index of the last parsed token by default would be the last token in the $list, because we're
|
||||
// assuming that all remaining tokens at state 2, are related to the to-be-explained statement.
|
||||
$idxOfLastParsedToken = $list->count - 1;
|
||||
$subList = new TokensList(array_slice($list->tokens, $list->idx));
|
||||
|
||||
$this->bodyParser = new Parser($subList);
|
||||
if (count($this->bodyParser->errors)) {
|
||||
foreach ($this->bodyParser->errors as $error) {
|
||||
$parser->errors[] = $error;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
$list->idx = $idxOfLastParsedToken;
|
||||
break;
|
||||
} elseif ($state === 3) {
|
||||
if (($token->type === Token::TYPE_OPERATOR) && ($token->value === '.')) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($this->explainedDatabase === null) {
|
||||
$lastIdx = $list->idx;
|
||||
$nextDot = $list->getNextOfTypeAndValue(Token::TYPE_OPERATOR, '.');
|
||||
$list->idx = $lastIdx;
|
||||
if ($nextDot !== null) {// We found a dot, so it must be a db.table name format
|
||||
$this->explainedDatabase = $token->value;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if ($this->explainedTable === null) {
|
||||
$this->explainedTable = $token->value;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($this->explainedColumn === null) {
|
||||
$this->explainedColumn = $token->value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($state !== 3 || $this->explainedTable !== null) {
|
||||
return;
|
||||
}
|
||||
|
||||
// We reached end of the state 3 and no table name was found
|
||||
/** Token parsed at this moment. */
|
||||
$token = $list->tokens[$list->idx];
|
||||
$parser->error('Expected a table name.', $token);
|
||||
}
|
||||
|
||||
public function build(): string
|
||||
{
|
||||
$str = $this->statementAlias;
|
||||
|
||||
if ($this->options !== null) {
|
||||
if (count($this->options->options)) {
|
||||
$str .= ' ';
|
||||
}
|
||||
|
||||
$str .= OptionsArray::build($this->options) . ' ';
|
||||
}
|
||||
|
||||
if ($this->options === null) {
|
||||
$str .= ' ';
|
||||
}
|
||||
|
||||
if ($this->bodyParser) {
|
||||
foreach ($this->bodyParser->statements as $statement) {
|
||||
$str .= $statement->build();
|
||||
}
|
||||
} elseif ($this->connectionId) {
|
||||
$str .= 'FOR CONNECTION ' . $this->connectionId;
|
||||
}
|
||||
|
||||
if ($this->explainedDatabase !== null && $this->explainedTable !== null) {
|
||||
$str .= Context::escape($this->explainedDatabase) . '.' . Context::escape($this->explainedTable);
|
||||
} elseif ($this->explainedTable !== null) {
|
||||
$str .= Context::escape($this->explainedTable);
|
||||
}
|
||||
|
||||
if ($this->explainedColumn !== null) {
|
||||
$str .= ' ' . Context::escape($this->explainedColumn);
|
||||
}
|
||||
|
||||
return $str;
|
||||
}
|
||||
}
|
||||
+254
@@ -0,0 +1,254 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Array2d;
|
||||
use PhpMyAdmin\SqlParser\Components\ArrayObj;
|
||||
use PhpMyAdmin\SqlParser\Components\IntoKeyword;
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Components\SetOperation;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function count;
|
||||
use function strlen;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `INSERT` statement.
|
||||
*
|
||||
* INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
|
||||
* [INTO] tbl_name
|
||||
* [PARTITION (partition_name,...)]
|
||||
* [(col_name,...)]
|
||||
* {VALUES | VALUE} ({expr | DEFAULT},...),(...),...
|
||||
* [ ON DUPLICATE KEY UPDATE
|
||||
* col_name=expr
|
||||
* [, col_name=expr] ... ]
|
||||
*
|
||||
* or
|
||||
*
|
||||
* INSERT [LOW_PRIORITY | DELAYED | HIGH_PRIORITY] [IGNORE]
|
||||
* [INTO] tbl_name
|
||||
* [PARTITION (partition_name,...)]
|
||||
* SET col_name={expr | DEFAULT}, ...
|
||||
* [ ON DUPLICATE KEY UPDATE
|
||||
* col_name=expr
|
||||
* [, col_name=expr] ... ]
|
||||
*
|
||||
* or
|
||||
*
|
||||
* INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE]
|
||||
* [INTO] tbl_name
|
||||
* [PARTITION (partition_name,...)]
|
||||
* [(col_name,...)]
|
||||
* SELECT ...
|
||||
* [ ON DUPLICATE KEY UPDATE
|
||||
* col_name=expr
|
||||
* [, col_name=expr] ... ]
|
||||
*/
|
||||
class InsertStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `INSERT` statements.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'LOW_PRIORITY' => 1,
|
||||
'DELAYED' => 2,
|
||||
'HIGH_PRIORITY' => 3,
|
||||
'IGNORE' => 4,
|
||||
];
|
||||
|
||||
/**
|
||||
* Tables used as target for this statement.
|
||||
*
|
||||
* @var IntoKeyword|null
|
||||
*/
|
||||
public $into;
|
||||
|
||||
/**
|
||||
* Values to be inserted.
|
||||
*
|
||||
* @var ArrayObj[]|null
|
||||
*/
|
||||
public $values;
|
||||
|
||||
/**
|
||||
* If SET clause is present
|
||||
* holds the SetOperation.
|
||||
*
|
||||
* @var SetOperation[]|null
|
||||
*/
|
||||
public $set;
|
||||
|
||||
/**
|
||||
* If SELECT clause is present
|
||||
* holds the SelectStatement.
|
||||
*
|
||||
* @var SelectStatement|null
|
||||
*/
|
||||
public $select;
|
||||
|
||||
/**
|
||||
* If WITH CTE is present
|
||||
* holds the WithStatement.
|
||||
*
|
||||
* @var WithStatement|null
|
||||
*/
|
||||
public $with;
|
||||
|
||||
/**
|
||||
* If ON DUPLICATE KEY UPDATE clause is present
|
||||
* holds the SetOperation.
|
||||
*
|
||||
* @var SetOperation[]|null
|
||||
*/
|
||||
public $onDuplicateSet;
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$ret = 'INSERT ' . $this->options;
|
||||
$ret = trim($ret) . ' INTO ' . $this->into;
|
||||
|
||||
if ($this->values !== null && count($this->values) > 0) {
|
||||
$ret .= ' VALUES ' . Array2d::build($this->values);
|
||||
} elseif ($this->set !== null && count($this->set) > 0) {
|
||||
$ret .= ' SET ' . SetOperation::build($this->set);
|
||||
} elseif ($this->select !== null && strlen((string) $this->select) > 0) {
|
||||
$ret .= ' ' . $this->select->build();
|
||||
}
|
||||
|
||||
if ($this->onDuplicateSet !== null && count($this->onDuplicateSet) > 0) {
|
||||
$ret .= ' ON DUPLICATE KEY UPDATE ' . SetOperation::build($this->onDuplicateSet);
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @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 `INSERT`.
|
||||
|
||||
// parse any options if provided
|
||||
$this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
++$list->idx;
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------------------------[ INTO ]----------------------------------> 1
|
||||
*
|
||||
* 1 -------------------------[ VALUES/VALUE/SET/SELECT ]-----------------------> 2
|
||||
*
|
||||
* 2 -------------------------[ ON DUPLICATE KEY UPDATE ]-----------------------> 3
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
/**
|
||||
* For keeping track of semi-states on encountering
|
||||
* ON DUPLICATE KEY UPDATE ...
|
||||
*/
|
||||
$miniState = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword !== 'INTO') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
++$list->idx;
|
||||
$this->into = IntoKeyword::parse(
|
||||
$parser,
|
||||
$list,
|
||||
['fromInsert' => true]
|
||||
);
|
||||
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if ($token->type !== Token::TYPE_KEYWORD) {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->keyword === 'VALUE' || $token->keyword === 'VALUES') {
|
||||
++$list->idx; // skip VALUES
|
||||
|
||||
$this->values = Array2d::parse($parser, $list);
|
||||
} elseif ($token->keyword === 'SET') {
|
||||
++$list->idx; // skip SET
|
||||
|
||||
$this->set = SetOperation::parse($parser, $list);
|
||||
} elseif ($token->keyword === 'SELECT') {
|
||||
$this->select = new SelectStatement($parser, $list);
|
||||
} elseif ($token->keyword === 'WITH') {
|
||||
$this->with = new WithStatement($parser, $list);
|
||||
} else {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$state = 2;
|
||||
$miniState = 1;
|
||||
} elseif ($state === 2) {
|
||||
$lastCount = $miniState;
|
||||
|
||||
if ($miniState === 1 && $token->keyword === 'ON') {
|
||||
++$miniState;
|
||||
} elseif ($miniState === 2 && $token->keyword === 'DUPLICATE') {
|
||||
++$miniState;
|
||||
} elseif ($miniState === 3 && $token->keyword === 'KEY') {
|
||||
++$miniState;
|
||||
} elseif ($miniState === 4 && $token->keyword === 'UPDATE') {
|
||||
++$miniState;
|
||||
}
|
||||
|
||||
if ($lastCount === $miniState) {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($miniState === 5) {
|
||||
++$list->idx;
|
||||
$this->onDuplicateSet = SetOperation::parse($parser, $list);
|
||||
$state = 3;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
}
|
||||
}
|
||||
+177
@@ -0,0 +1,177 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Exceptions\ParserException;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function array_slice;
|
||||
use function is_int;
|
||||
|
||||
/** KILL [HARD|SOFT]
|
||||
* {
|
||||
* {CONNECTION|QUERY} id |
|
||||
* QUERY ID query_id | USER user_name
|
||||
* }
|
||||
*/
|
||||
class KillStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'HARD' => 1,
|
||||
'SOFT' => 1,
|
||||
'CONNECTION' => 2,
|
||||
'QUERY' => 2,
|
||||
'USER' => 2,
|
||||
];
|
||||
|
||||
/**
|
||||
* Holds the identifier if explicitly set
|
||||
*
|
||||
* @psalm-var Statement|int|null
|
||||
*/
|
||||
public $identifier = null;
|
||||
|
||||
/**
|
||||
* Whether MariaDB ID keyword is used or not.
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
public $idKeywordUsed = false;
|
||||
|
||||
/**
|
||||
* Whether parenthesis used around the identifier or not
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
public $parenthesisUsed = false;
|
||||
|
||||
/** @throws ParserException */
|
||||
public function parse(Parser $parser, TokensList $list): void
|
||||
{
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 --------------------- [ OPTIONS PARSED ] --------------------------> 0
|
||||
*
|
||||
* 0 -------------------- [ number ] -----------------------------------> 2
|
||||
*
|
||||
* 0 -------------------- [ ( ] ----------------------------------------> 3
|
||||
*
|
||||
* 0 -------------------- [ QUERY ID ] ---------------------------------> 0
|
||||
*
|
||||
* 3 -------------------- [ number ] -----------------------------------> 3
|
||||
*
|
||||
* 3 -------------------- [ SELECT STATEMENT ] -------------------------> 2
|
||||
*
|
||||
* 3 -------------------- [ ) ] ----------------------------------------> 2
|
||||
*
|
||||
* 2 ----------------------------------------------------------> Final state
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
++$list->idx; // Skipping `KILL`.
|
||||
$this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
++$list->idx;
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
if ($token->type === Token::TYPE_WHITESPACE || $token->type === Token::TYPE_COMMENT) {
|
||||
continue;
|
||||
}
|
||||
|
||||
switch ($state) {
|
||||
case 0:
|
||||
$currIdx = $list->idx;
|
||||
$prev = $list->getPreviousOfType(Token::TYPE_KEYWORD);
|
||||
$list->idx = $currIdx;
|
||||
if ($token->type === Token::TYPE_NUMBER && is_int($token->value)) {
|
||||
$this->identifier = $token->value;
|
||||
$state = 2;
|
||||
} elseif ($token->type === Token::TYPE_OPERATOR && $token->value === '(') {
|
||||
$this->parenthesisUsed = true;
|
||||
$state = 3;
|
||||
} elseif ($prev && $token->value === 'ID' && $prev->value === 'QUERY') {
|
||||
$this->idKeywordUsed = true;
|
||||
$state = 0;
|
||||
} else {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break 2;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 3:
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->value === 'SELECT') {
|
||||
$subList = new TokensList(array_slice($list->tokens, $list->idx - 1));
|
||||
$subParser = new Parser($subList);
|
||||
if ($subParser->errors !== []) {
|
||||
foreach ($subParser->errors as $error) {
|
||||
$parser->errors[] = $error;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
$this->identifier = $subParser->statements[0];
|
||||
$state = 2;
|
||||
} elseif ($token->type === Token::TYPE_OPERATOR && $token->value === ')') {
|
||||
$state = 2;
|
||||
} elseif ($token->type === Token::TYPE_NUMBER && is_int($token->value)) {
|
||||
$this->identifier = $token->value;
|
||||
$state = 3;
|
||||
} else {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break 2;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ($state !== 2) {
|
||||
$token = $list->tokens[$list->idx];
|
||||
$parser->error('Unexpected end of the KILL statement.', $token);
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$ret = 'KILL';
|
||||
|
||||
if ($this->options !== null && $this->options->options !== []) {
|
||||
$ret .= ' ' . OptionsArray::build($this->options);
|
||||
}
|
||||
|
||||
if ($this->idKeywordUsed) {
|
||||
$ret .= ' ID';
|
||||
}
|
||||
|
||||
$identifier = (string) $this->identifier;
|
||||
if ($this->parenthesisUsed) {
|
||||
$ret .= ' (' . $identifier . ')';
|
||||
} else {
|
||||
$ret .= ' ' . $identifier;
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
}
|
||||
+410
@@ -0,0 +1,410 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\ArrayObj;
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Components\ExpressionArray;
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Components\SetOperation;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function count;
|
||||
use function strlen;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `LOAD` statement.
|
||||
*
|
||||
* LOAD DATA [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name'
|
||||
* [REPLACE | IGNORE]
|
||||
* INTO TABLE tbl_name
|
||||
* [PARTITION (partition_name,...)]
|
||||
* [CHARACTER SET charset_name]
|
||||
* [{FIELDS | COLUMNS}
|
||||
* [TERMINATED BY 'string']
|
||||
* [[OPTIONALLY] ENCLOSED BY 'char']
|
||||
* [ESCAPED BY 'char']
|
||||
* ]
|
||||
* [LINES
|
||||
* [STARTING BY 'string']
|
||||
* [TERMINATED BY 'string']
|
||||
* ]
|
||||
* [IGNORE number {LINES | ROWS}]
|
||||
* [(col_name_or_user_var,...)]
|
||||
* [SET col_name = expr,...]
|
||||
*/
|
||||
class LoadStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `LOAD` statements and their slot ID.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'LOW_PRIORITY' => 1,
|
||||
'CONCURRENT' => 1,
|
||||
'LOCAL' => 2,
|
||||
];
|
||||
|
||||
/**
|
||||
* FIELDS/COLUMNS Options for `LOAD DATA...INFILE` statements.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $FIELDS_OPTIONS = [
|
||||
'TERMINATED BY' => [
|
||||
1,
|
||||
'expr',
|
||||
],
|
||||
'OPTIONALLY' => 2,
|
||||
'ENCLOSED BY' => [
|
||||
3,
|
||||
'expr',
|
||||
],
|
||||
'ESCAPED BY' => [
|
||||
4,
|
||||
'expr',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* LINES Options for `LOAD DATA...INFILE` statements.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $LINES_OPTIONS = [
|
||||
'STARTING BY' => [
|
||||
1,
|
||||
'expr',
|
||||
],
|
||||
'TERMINATED BY' => [
|
||||
2,
|
||||
'expr',
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* File name being used to load data.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $file_name;
|
||||
|
||||
/**
|
||||
* Table used as destination for this statement.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $table;
|
||||
|
||||
/**
|
||||
* Partitions used as source for this statement.
|
||||
*
|
||||
* @var ArrayObj|null
|
||||
*/
|
||||
public $partition;
|
||||
|
||||
/**
|
||||
* Character set used in this statement.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $charset_name;
|
||||
|
||||
/**
|
||||
* Options for FIELDS/COLUMNS keyword.
|
||||
*
|
||||
* @see static::$FIELDS_OPTIONS
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $fields_options;
|
||||
|
||||
/**
|
||||
* Whether to use `FIELDS` or `COLUMNS` while building.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $fields_keyword;
|
||||
|
||||
/**
|
||||
* Options for OPTIONS keyword.
|
||||
*
|
||||
* @see static::$LINES_OPTIONS
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $lines_options;
|
||||
|
||||
/**
|
||||
* Column names or user variables.
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $col_name_or_user_var;
|
||||
|
||||
/**
|
||||
* SET clause's updated values(optional).
|
||||
*
|
||||
* @var SetOperation[]|null
|
||||
*/
|
||||
public $set;
|
||||
|
||||
/**
|
||||
* Ignore 'number' LINES/ROWS.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $ignore_number;
|
||||
|
||||
/**
|
||||
* REPLACE/IGNORE Keyword.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $replace_ignore;
|
||||
|
||||
/**
|
||||
* LINES/ROWS Keyword.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $lines_rows;
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$ret = 'LOAD DATA ' . $this->options
|
||||
. ' INFILE ' . $this->file_name;
|
||||
|
||||
if ($this->replace_ignore !== null) {
|
||||
$ret .= ' ' . trim($this->replace_ignore);
|
||||
}
|
||||
|
||||
$ret .= ' INTO TABLE ' . $this->table;
|
||||
|
||||
if ($this->partition !== null && strlen((string) $this->partition) > 0) {
|
||||
$ret .= ' PARTITION ' . ArrayObj::build($this->partition);
|
||||
}
|
||||
|
||||
if ($this->charset_name !== null) {
|
||||
$ret .= ' CHARACTER SET ' . $this->charset_name;
|
||||
}
|
||||
|
||||
if ($this->fields_keyword !== null) {
|
||||
$ret .= ' ' . $this->fields_keyword . ' ' . $this->fields_options;
|
||||
}
|
||||
|
||||
if ($this->lines_options !== null && strlen((string) $this->lines_options) > 0) {
|
||||
$ret .= ' LINES ' . $this->lines_options;
|
||||
}
|
||||
|
||||
if ($this->ignore_number !== null) {
|
||||
$ret .= ' IGNORE ' . $this->ignore_number . ' ' . $this->lines_rows;
|
||||
}
|
||||
|
||||
if ($this->col_name_or_user_var !== null && count($this->col_name_or_user_var) > 0) {
|
||||
$ret .= ' ' . ExpressionArray::build($this->col_name_or_user_var);
|
||||
}
|
||||
|
||||
if ($this->set !== null && count($this->set) > 0) {
|
||||
$ret .= ' SET ' . SetOperation::build($this->set);
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @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 `LOAD DATA`.
|
||||
|
||||
// parse any options if provided
|
||||
$this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
++$list->idx;
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword !== 'INFILE') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->type !== Token::TYPE_KEYWORD) {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
++$list->idx;
|
||||
$this->file_name = Expression::parse(
|
||||
$parser,
|
||||
$list,
|
||||
['parseField' => 'file']
|
||||
);
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if ($token->keyword === 'REPLACE' || $token->keyword === 'IGNORE') {
|
||||
$this->replace_ignore = trim($token->keyword);
|
||||
} elseif ($token->keyword === 'INTO') {
|
||||
$state = 2;
|
||||
}
|
||||
}
|
||||
} elseif ($state === 2) {
|
||||
if ($token->type !== Token::TYPE_KEYWORD || $token->keyword !== 'TABLE') {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
++$list->idx;
|
||||
$this->table = Expression::parse($parser, $list, ['parseField' => 'table', 'breakOnAlias' => true]);
|
||||
$state = 3;
|
||||
} elseif ($state >= 3 && $state <= 7) {
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
$newState = $this->parseKeywordsAccordingToState($parser, $list, $state);
|
||||
if ($newState === $state) {
|
||||
// Avoid infinite loop
|
||||
break;
|
||||
}
|
||||
} elseif ($token->type === Token::TYPE_OPERATOR && $token->token === '(') {
|
||||
$this->col_name_or_user_var
|
||||
= ExpressionArray::parse($parser, $list);
|
||||
$state = 7;
|
||||
} else {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser The parser
|
||||
* @param TokensList $list A token list
|
||||
* @param string $keyword The keyword
|
||||
*/
|
||||
public function parseFileOptions(Parser $parser, TokensList $list, $keyword = 'FIELDS'): void
|
||||
{
|
||||
++$list->idx;
|
||||
|
||||
if ($keyword === 'FIELDS' || $keyword === 'COLUMNS') {
|
||||
// parse field options
|
||||
$this->fields_options = OptionsArray::parse($parser, $list, static::$FIELDS_OPTIONS);
|
||||
|
||||
$this->fields_keyword = $keyword;
|
||||
} else {
|
||||
// parse line options
|
||||
$this->lines_options = OptionsArray::parse($parser, $list, static::$LINES_OPTIONS);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser
|
||||
* @param TokensList $list
|
||||
* @param int $state
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function parseKeywordsAccordingToState($parser, $list, $state)
|
||||
{
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
switch ($state) {
|
||||
case 3:
|
||||
if ($token->keyword === 'PARTITION') {
|
||||
++$list->idx;
|
||||
$this->partition = ArrayObj::parse($parser, $list);
|
||||
|
||||
return 4;
|
||||
}
|
||||
|
||||
// no break
|
||||
case 4:
|
||||
if ($token->keyword === 'CHARACTER SET') {
|
||||
++$list->idx;
|
||||
$this->charset_name = Expression::parse($parser, $list);
|
||||
|
||||
return 5;
|
||||
}
|
||||
|
||||
// no break
|
||||
case 5:
|
||||
if ($token->keyword === 'FIELDS' || $token->keyword === 'COLUMNS' || $token->keyword === 'LINES') {
|
||||
$this->parseFileOptions($parser, $list, $token->value);
|
||||
|
||||
return 6;
|
||||
}
|
||||
|
||||
// no break
|
||||
case 6:
|
||||
if ($token->keyword === 'IGNORE') {
|
||||
++$list->idx;
|
||||
|
||||
$this->ignore_number = Expression::parse($parser, $list);
|
||||
$nextToken = $list->getNextOfType(Token::TYPE_KEYWORD);
|
||||
|
||||
if (
|
||||
$nextToken->type === Token::TYPE_KEYWORD
|
||||
&& (($nextToken->keyword === 'LINES')
|
||||
|| ($nextToken->keyword === 'ROWS'))
|
||||
) {
|
||||
$this->lines_rows = $nextToken->token;
|
||||
}
|
||||
|
||||
return 7;
|
||||
}
|
||||
|
||||
// no break
|
||||
case 7:
|
||||
if ($token->keyword === 'SET') {
|
||||
++$list->idx;
|
||||
$this->set = SetOperation::parse($parser, $list);
|
||||
|
||||
return 8;
|
||||
}
|
||||
|
||||
// no break
|
||||
default:
|
||||
}
|
||||
|
||||
return $state;
|
||||
}
|
||||
}
|
||||
+131
@@ -0,0 +1,131 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\LockExpression;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `LOCK` statement.
|
||||
*/
|
||||
class LockStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Tables with their Lock expressions.
|
||||
*
|
||||
* @var LockExpression[]
|
||||
*/
|
||||
public $locked = [];
|
||||
|
||||
/**
|
||||
* Whether it's a LOCK statement
|
||||
* if false, it's an UNLOCK statement
|
||||
*
|
||||
* @var bool
|
||||
*/
|
||||
public $isLock = true;
|
||||
|
||||
/**
|
||||
* @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)
|
||||
{
|
||||
if ($list->tokens[$list->idx]->value === 'UNLOCK') {
|
||||
// this is in fact an UNLOCK statement
|
||||
$this->isLock = false;
|
||||
}
|
||||
|
||||
++$list->idx; // Skipping `LOCK`.
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------- [ TABLES ] -----------------> 1
|
||||
* 1 -------------- [ lock_expr ] ----------------> 2
|
||||
* 2 ------------------ [ , ] --------------------> 1
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
/**
|
||||
* Previous parsed token
|
||||
*/
|
||||
$prevToken = null;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if ($token->keyword !== 'TABLES') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$state = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($state === 1) {
|
||||
if (! $this->isLock) {
|
||||
// UNLOCK statement should not have any more tokens
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$this->locked[] = LockExpression::parse($parser, $list);
|
||||
$state = 2;
|
||||
} elseif ($state === 2) {
|
||||
if ($token->value === ',') {
|
||||
// move over to parsing next lock expression
|
||||
$state = 1;
|
||||
}
|
||||
}
|
||||
|
||||
$prevToken = $token;
|
||||
}
|
||||
|
||||
if ($state === 2 || $prevToken === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
$parser->error('Unexpected end of LOCK statement.', $prevToken);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
return trim(($this->isLock ? 'LOCK' : 'UNLOCK')
|
||||
. ' TABLES ' . LockExpression::build($this->locked));
|
||||
}
|
||||
}
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
/**
|
||||
* Maintenance statement.
|
||||
*
|
||||
* They follow the syntax:
|
||||
* STMT [some options] tbl_name [, tbl_name] ... [some more options]
|
||||
*/
|
||||
class MaintenanceStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Tables maintained.
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $tables;
|
||||
|
||||
/**
|
||||
* Function called after the token was processed.
|
||||
*
|
||||
* Parses the additional options from the end.
|
||||
*
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param TokensList $list the list of tokens to be parsed
|
||||
* @param Token $token the token that is being parsed
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function after(Parser $parser, TokensList $list, Token $token)
|
||||
{
|
||||
// [some options] is going to be parsed first.
|
||||
//
|
||||
// There is a parser specified in `Parser::$KEYWORD_PARSERS`
|
||||
// which parses the name of the tables.
|
||||
//
|
||||
// Finally, we parse here [some more options] and that's all.
|
||||
++$list->idx;
|
||||
$this->options->merge(
|
||||
OptionsArray::parse(
|
||||
$parser,
|
||||
$list,
|
||||
static::$OPTIONS
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
Vendored
+56
@@ -0,0 +1,56 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
/**
|
||||
* Not implemented (yet) statements.
|
||||
*
|
||||
* The `after` function makes the parser jump straight to the first delimiter.
|
||||
*/
|
||||
class NotImplementedStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* The part of the statement that can't be parsed.
|
||||
*
|
||||
* @var Token[]
|
||||
*/
|
||||
public $unknown = [];
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
// Building the parsed part of the query (if any).
|
||||
$query = parent::build() . ' ';
|
||||
|
||||
// Rebuilding the unknown part from tokens.
|
||||
foreach ($this->unknown as $token) {
|
||||
$query .= $token->token;
|
||||
}
|
||||
|
||||
return $query;
|
||||
}
|
||||
|
||||
/**
|
||||
* @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)
|
||||
{
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
if ($list->tokens[$list->idx]->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
$this->unknown[] = $list->tokens[$list->idx];
|
||||
}
|
||||
}
|
||||
}
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
|
||||
/**
|
||||
* `OPTIMIZE` statement.
|
||||
*
|
||||
* OPTIMIZE [NO_WRITE_TO_BINLOG | LOCAL] TABLE
|
||||
* tbl_name [, tbl_name] ...
|
||||
*/
|
||||
class OptimizeStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'TABLE' => 1,
|
||||
|
||||
'NO_WRITE_TO_BINLOG' => 2,
|
||||
'LOCAL' => 3,
|
||||
];
|
||||
|
||||
/**
|
||||
* Optimized tables.
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $tables;
|
||||
}
|
||||
+145
@@ -0,0 +1,145 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function in_array;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `PURGE` statement.
|
||||
*
|
||||
* PURGE { BINARY | MASTER } LOGS
|
||||
* { TO 'log_name' | BEFORE datetime_expr }
|
||||
*/
|
||||
class PurgeStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* The type of logs
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $log_type;
|
||||
|
||||
/**
|
||||
* The end option of this query.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $end_option;
|
||||
|
||||
/**
|
||||
* The end expr of this query.
|
||||
*
|
||||
* @var string|null
|
||||
*/
|
||||
public $end_expr;
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$ret = 'PURGE ' . $this->log_type . ' LOGS '
|
||||
. ($this->end_option !== null ? ($this->end_option . ' ' . $this->end_expr) : '');
|
||||
|
||||
return trim($ret);
|
||||
}
|
||||
|
||||
/**
|
||||
* @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 `PURGE`.
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
$prevToken = null;
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
switch ($state) {
|
||||
case 0:
|
||||
// parse `{ BINARY | MASTER }`
|
||||
$this->log_type = self::parseExpectedKeyword($parser, $token, ['BINARY', 'MASTER']);
|
||||
break;
|
||||
case 1:
|
||||
// parse `LOGS`
|
||||
self::parseExpectedKeyword($parser, $token, ['LOGS']);
|
||||
break;
|
||||
case 2:
|
||||
// parse `{ TO | BEFORE }`
|
||||
$this->end_option = self::parseExpectedKeyword($parser, $token, ['TO', 'BEFORE']);
|
||||
break;
|
||||
case 3:
|
||||
// parse `expr`
|
||||
$this->end_expr = Expression::parse($parser, $list, []);
|
||||
break;
|
||||
default:
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$state++;
|
||||
$prevToken = $token;
|
||||
}
|
||||
|
||||
// Only one possible end state
|
||||
if ($state === 4) {
|
||||
return;
|
||||
}
|
||||
|
||||
$parser->error('Unexpected token.', $prevToken);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse expected keyword (or throw relevant error)
|
||||
*
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param Token $token token to be parsed
|
||||
* @param string[] $expectedKeywords array of possibly expected keywords at this point
|
||||
*
|
||||
* @return mixed|null
|
||||
*/
|
||||
private static function parseExpectedKeyword($parser, $token, $expectedKeywords)
|
||||
{
|
||||
if ($token->type === Token::TYPE_KEYWORD) {
|
||||
if (in_array($token->keyword, $expectedKeywords)) {
|
||||
return $token->keyword;
|
||||
}
|
||||
|
||||
$parser->error('Unexpected keyword', $token);
|
||||
} else {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
}
|
||||
+56
@@ -0,0 +1,56 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\RenameOperation;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
/**
|
||||
* `RENAME` statement.
|
||||
*
|
||||
* RENAME TABLE tbl_name TO new_tbl_name
|
||||
* [, tbl_name2 TO new_tbl_name2] ...
|
||||
*/
|
||||
class RenameStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* The old and new names of the tables.
|
||||
*
|
||||
* @var RenameOperation[]|null
|
||||
*/
|
||||
public $renames;
|
||||
|
||||
/**
|
||||
* Function called before the token is processed.
|
||||
*
|
||||
* Skips the `TABLE` keyword after `RENAME`.
|
||||
*
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param TokensList $list the list of tokens to be parsed
|
||||
* @param Token $token the token that is being parsed
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function before(Parser $parser, TokensList $list, Token $token)
|
||||
{
|
||||
if (($token->type !== Token::TYPE_KEYWORD) || ($token->keyword !== 'RENAME')) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Checking if it is the beginning of the query.
|
||||
$list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'TABLE');
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
return 'RENAME TABLE ' . RenameOperation::build($this->renames);
|
||||
}
|
||||
}
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
/**
|
||||
* `REPAIR` statement.
|
||||
*
|
||||
* REPAIR [NO_WRITE_TO_BINLOG | LOCAL] TABLE
|
||||
* tbl_name [, tbl_name] ...
|
||||
* [QUICK] [EXTENDED] [USE_FRM]
|
||||
*/
|
||||
class RepairStatement extends MaintenanceStatement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'TABLE' => 1,
|
||||
|
||||
'NO_WRITE_TO_BINLOG' => 2,
|
||||
'LOCAL' => 3,
|
||||
|
||||
'QUICK' => 4,
|
||||
'EXTENDED' => 5,
|
||||
'USE_FRM' => 6,
|
||||
];
|
||||
}
|
||||
+188
@@ -0,0 +1,188 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Array2d;
|
||||
use PhpMyAdmin\SqlParser\Components\IntoKeyword;
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Components\SetOperation;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
use function count;
|
||||
use function strlen;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `REPLACE` statement.
|
||||
*
|
||||
* REPLACE [LOW_PRIORITY | DELAYED]
|
||||
* [INTO] tbl_name [(col_name,...)]
|
||||
* {VALUES | VALUE} ({expr | DEFAULT},...),(...),...
|
||||
*
|
||||
* or
|
||||
*
|
||||
* REPLACE [LOW_PRIORITY | DELAYED]
|
||||
* [INTO] tbl_name
|
||||
* SET col_name={expr | DEFAULT}, ...
|
||||
*
|
||||
* or
|
||||
*
|
||||
* REPLACE [LOW_PRIORITY | DELAYED]
|
||||
* [INTO] tbl_name
|
||||
* [PARTITION (partition_name,...)]
|
||||
* [(col_name,...)]
|
||||
* SELECT ...
|
||||
*/
|
||||
class ReplaceStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `REPLACE` statements and their slot ID.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'LOW_PRIORITY' => 1,
|
||||
'DELAYED' => 1,
|
||||
];
|
||||
|
||||
/**
|
||||
* Tables used as target for this statement.
|
||||
*
|
||||
* @var IntoKeyword|null
|
||||
*/
|
||||
public $into;
|
||||
|
||||
/**
|
||||
* Values to be replaced.
|
||||
*
|
||||
* @var Array2d[]|null
|
||||
*/
|
||||
public $values;
|
||||
|
||||
/**
|
||||
* If SET clause is present
|
||||
* holds the SetOperation.
|
||||
*
|
||||
* @var SetOperation[]|null
|
||||
*/
|
||||
public $set;
|
||||
|
||||
/**
|
||||
* If SELECT clause is present
|
||||
* holds the SelectStatement.
|
||||
*
|
||||
* @var SelectStatement|null
|
||||
*/
|
||||
public $select;
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$ret = 'REPLACE ' . $this->options;
|
||||
$ret = trim($ret) . ' INTO ' . $this->into;
|
||||
|
||||
if ($this->values !== null && count($this->values) > 0) {
|
||||
$ret .= ' VALUES ' . Array2d::build($this->values);
|
||||
} elseif ($this->set !== null && count($this->set) > 0) {
|
||||
$ret .= ' SET ' . SetOperation::build($this->set);
|
||||
} elseif ($this->select !== null && strlen((string) $this->select) > 0) {
|
||||
$ret .= ' ' . $this->select->build();
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param TokensList $list the list of tokens to be parsed
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function parse(Parser $parser, TokensList $list)
|
||||
{
|
||||
++$list->idx; // Skipping `REPLACE`.
|
||||
|
||||
// parse any options if provided
|
||||
$this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
|
||||
++$list->idx;
|
||||
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------------------------[ INTO ]----------------------------------> 1
|
||||
*
|
||||
* 1 -------------------------[ VALUES/VALUE/SET/SELECT ]-----------------------> 2
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// End of statement.
|
||||
if ($token->type === Token::TYPE_DELIMITER) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if (($token->type === Token::TYPE_WHITESPACE) || ($token->type === Token::TYPE_COMMENT)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->type === Token::TYPE_KEYWORD && $token->keyword !== 'INTO') {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
++$list->idx;
|
||||
$this->into = IntoKeyword::parse(
|
||||
$parser,
|
||||
$list,
|
||||
['fromReplace' => true]
|
||||
);
|
||||
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if ($token->type !== Token::TYPE_KEYWORD) {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
if ($token->keyword === 'VALUE' || $token->keyword === 'VALUES') {
|
||||
++$list->idx; // skip VALUES
|
||||
|
||||
$this->values = Array2d::parse($parser, $list);
|
||||
} elseif ($token->keyword === 'SET') {
|
||||
++$list->idx; // skip SET
|
||||
|
||||
$this->set = SetOperation::parse($parser, $list);
|
||||
} elseif ($token->keyword === 'SELECT') {
|
||||
$this->select = new SelectStatement($parser, $list);
|
||||
} else {
|
||||
$parser->error('Unexpected keyword.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$state = 2;
|
||||
}
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
}
|
||||
}
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
/**
|
||||
* `RESTORE` statement.
|
||||
*
|
||||
* RESTORE TABLE tbl_name [, tbl_name] ... FROM '/path/to/backup/directory'
|
||||
*/
|
||||
class RestoreStatement extends MaintenanceStatement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'TABLE' => 1,
|
||||
|
||||
'FROM' => [
|
||||
2,
|
||||
'var',
|
||||
],
|
||||
];
|
||||
}
|
||||
+370
@@ -0,0 +1,370 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\ArrayObj;
|
||||
use PhpMyAdmin\SqlParser\Components\CaseExpression;
|
||||
use PhpMyAdmin\SqlParser\Components\Condition;
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Components\FunctionCall;
|
||||
use PhpMyAdmin\SqlParser\Components\GroupKeyword;
|
||||
use PhpMyAdmin\SqlParser\Components\IndexHint;
|
||||
use PhpMyAdmin\SqlParser\Components\IntoKeyword;
|
||||
use PhpMyAdmin\SqlParser\Components\JoinKeyword;
|
||||
use PhpMyAdmin\SqlParser\Components\Limit;
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Components\OrderKeyword;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
|
||||
/**
|
||||
* `SELECT` statement.
|
||||
*
|
||||
* SELECT
|
||||
* [ALL | DISTINCT | DISTINCTROW ]
|
||||
* [HIGH_PRIORITY]
|
||||
* [MAX_STATEMENT_TIME = N]
|
||||
* [STRAIGHT_JOIN]
|
||||
* [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
|
||||
* [SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
|
||||
* select_expr [, select_expr ...]
|
||||
* [FROM table_references
|
||||
* [PARTITION partition_list]
|
||||
* [WHERE where_condition]
|
||||
* [GROUP BY {col_name | expr | position}
|
||||
* [ASC | DESC], ... [WITH ROLLUP]]
|
||||
* [HAVING where_condition]
|
||||
* [ORDER BY {col_name | expr | position}
|
||||
* [ASC | DESC], ...]
|
||||
* [LIMIT {[offset,] row_count | row_count OFFSET offset}]
|
||||
* [PROCEDURE procedure_name(argument_list)]
|
||||
* [INTO OUTFILE 'file_name'
|
||||
* [CHARACTER SET charset_name]
|
||||
* export_options
|
||||
* | INTO DUMPFILE 'file_name'
|
||||
* | INTO var_name [, var_name]]
|
||||
* [FOR UPDATE | LOCK IN SHARE MODE]]
|
||||
*/
|
||||
class SelectStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `SELECT` statements and their slot ID.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'ALL' => 1,
|
||||
'DISTINCT' => 1,
|
||||
'DISTINCTROW' => 1,
|
||||
'HIGH_PRIORITY' => 2,
|
||||
'MAX_STATEMENT_TIME' => [
|
||||
3,
|
||||
'var=',
|
||||
],
|
||||
'STRAIGHT_JOIN' => 4,
|
||||
'SQL_SMALL_RESULT' => 5,
|
||||
'SQL_BIG_RESULT' => 6,
|
||||
'SQL_BUFFER_RESULT' => 7,
|
||||
'SQL_CACHE' => 8,
|
||||
'SQL_NO_CACHE' => 8,
|
||||
'SQL_CALC_FOUND_ROWS' => 9,
|
||||
];
|
||||
|
||||
/**
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $GROUP_OPTIONS = ['WITH ROLLUP' => 1];
|
||||
|
||||
/**
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $END_OPTIONS = [
|
||||
'FOR UPDATE' => 1,
|
||||
'LOCK IN SHARE MODE' => 1,
|
||||
];
|
||||
|
||||
/**
|
||||
* The clauses of this statement, in order.
|
||||
*
|
||||
* @see Statement::$CLAUSES
|
||||
*
|
||||
* @var array<string, array<int, int|string>>
|
||||
* @psalm-var array<string, array{non-empty-string, (1|2|3)}>
|
||||
*/
|
||||
public static $CLAUSES = [
|
||||
'SELECT' => [
|
||||
'SELECT',
|
||||
2,
|
||||
],
|
||||
// Used for options.
|
||||
'_OPTIONS' => [
|
||||
'_OPTIONS',
|
||||
1,
|
||||
],
|
||||
// Used for selected expressions.
|
||||
'_SELECT' => [
|
||||
'SELECT',
|
||||
1,
|
||||
],
|
||||
'INTO' => [
|
||||
'INTO',
|
||||
3,
|
||||
],
|
||||
'FROM' => [
|
||||
'FROM',
|
||||
3,
|
||||
],
|
||||
'FORCE' => [
|
||||
'FORCE',
|
||||
1,
|
||||
],
|
||||
'USE' => [
|
||||
'USE',
|
||||
1,
|
||||
],
|
||||
'IGNORE' => [
|
||||
'IGNORE',
|
||||
3,
|
||||
],
|
||||
'PARTITION' => [
|
||||
'PARTITION',
|
||||
3,
|
||||
],
|
||||
|
||||
'JOIN' => [
|
||||
'JOIN',
|
||||
1,
|
||||
],
|
||||
'FULL JOIN' => [
|
||||
'FULL JOIN',
|
||||
1,
|
||||
],
|
||||
'INNER JOIN' => [
|
||||
'INNER JOIN',
|
||||
1,
|
||||
],
|
||||
'LEFT JOIN' => [
|
||||
'LEFT JOIN',
|
||||
1,
|
||||
],
|
||||
'LEFT OUTER JOIN' => [
|
||||
'LEFT OUTER JOIN',
|
||||
1,
|
||||
],
|
||||
'RIGHT JOIN' => [
|
||||
'RIGHT JOIN',
|
||||
1,
|
||||
],
|
||||
'RIGHT OUTER JOIN' => [
|
||||
'RIGHT OUTER JOIN',
|
||||
1,
|
||||
],
|
||||
'NATURAL JOIN' => [
|
||||
'NATURAL JOIN',
|
||||
1,
|
||||
],
|
||||
'NATURAL LEFT JOIN' => [
|
||||
'NATURAL LEFT JOIN',
|
||||
1,
|
||||
],
|
||||
'NATURAL RIGHT JOIN' => [
|
||||
'NATURAL RIGHT JOIN',
|
||||
1,
|
||||
],
|
||||
'NATURAL LEFT OUTER JOIN' => [
|
||||
'NATURAL LEFT OUTER JOIN',
|
||||
1,
|
||||
],
|
||||
'NATURAL RIGHT OUTER JOIN' => [
|
||||
'NATURAL RIGHT JOIN',
|
||||
1,
|
||||
],
|
||||
'WHERE' => [
|
||||
'WHERE',
|
||||
3,
|
||||
],
|
||||
'GROUP BY' => [
|
||||
'GROUP BY',
|
||||
3,
|
||||
],
|
||||
'_GROUP_OPTIONS' => [
|
||||
'_GROUP_OPTIONS',
|
||||
1,
|
||||
],
|
||||
'HAVING' => [
|
||||
'HAVING',
|
||||
3,
|
||||
],
|
||||
'ORDER BY' => [
|
||||
'ORDER BY',
|
||||
3,
|
||||
],
|
||||
'LIMIT' => [
|
||||
'LIMIT',
|
||||
3,
|
||||
],
|
||||
'PROCEDURE' => [
|
||||
'PROCEDURE',
|
||||
3,
|
||||
],
|
||||
'UNION' => [
|
||||
'UNION',
|
||||
1,
|
||||
],
|
||||
'EXCEPT' => [
|
||||
'EXCEPT',
|
||||
1,
|
||||
],
|
||||
'INTERSECT' => [
|
||||
'INTERSECT',
|
||||
1,
|
||||
],
|
||||
'_END_OPTIONS' => [
|
||||
'_END_OPTIONS',
|
||||
1,
|
||||
],
|
||||
// These are available only when `UNION` is present.
|
||||
// 'ORDER BY' => ['ORDER BY', 3],
|
||||
// 'LIMIT' => ['LIMIT', 3],
|
||||
];
|
||||
|
||||
/**
|
||||
* Expressions that are being selected by this statement.
|
||||
*
|
||||
* @var (CaseExpression|Expression)[]
|
||||
*/
|
||||
public $expr = [];
|
||||
|
||||
/**
|
||||
* Tables used as sources for this statement.
|
||||
*
|
||||
* @var Expression[]
|
||||
*/
|
||||
public $from = [];
|
||||
|
||||
/**
|
||||
* Index hints
|
||||
*
|
||||
* @var IndexHint[]|null
|
||||
*/
|
||||
public $index_hints;
|
||||
|
||||
/**
|
||||
* Partitions used as source for this statement.
|
||||
*
|
||||
* @var ArrayObj|null
|
||||
*/
|
||||
public $partition;
|
||||
|
||||
/**
|
||||
* Conditions used for filtering each row of the result set.
|
||||
*
|
||||
* @var Condition[]|null
|
||||
*/
|
||||
public $where;
|
||||
|
||||
/**
|
||||
* Conditions used for grouping the result set.
|
||||
*
|
||||
* @var GroupKeyword[]|null
|
||||
*/
|
||||
public $group;
|
||||
|
||||
/**
|
||||
* List of options available for the GROUP BY component.
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $group_options;
|
||||
|
||||
/**
|
||||
* Conditions used for filtering the result set.
|
||||
*
|
||||
* @var Condition[]|null
|
||||
*/
|
||||
public $having;
|
||||
|
||||
/**
|
||||
* Specifies the order of the rows in the result set.
|
||||
*
|
||||
* @var OrderKeyword[]|null
|
||||
*/
|
||||
public $order;
|
||||
|
||||
/**
|
||||
* Conditions used for limiting the size of the result set.
|
||||
*
|
||||
* @var Limit|null
|
||||
*/
|
||||
public $limit;
|
||||
|
||||
/**
|
||||
* Procedure that should process the data in the result set.
|
||||
*
|
||||
* @var FunctionCall|null
|
||||
*/
|
||||
public $procedure;
|
||||
|
||||
/**
|
||||
* Destination of this result set.
|
||||
*
|
||||
* @var IntoKeyword|null
|
||||
*/
|
||||
public $into;
|
||||
|
||||
/**
|
||||
* Joins.
|
||||
*
|
||||
* @var JoinKeyword[]|null
|
||||
*/
|
||||
public $join;
|
||||
|
||||
/**
|
||||
* Unions.
|
||||
*
|
||||
* @var SelectStatement[]
|
||||
*/
|
||||
public $union = [];
|
||||
|
||||
/**
|
||||
* The end options of this query.
|
||||
*
|
||||
* @see static::$END_OPTIONS
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $end_options;
|
||||
|
||||
/**
|
||||
* Gets the clauses of this statement.
|
||||
*
|
||||
* @return array<string, array<int, int|string>>
|
||||
* @psalm-return array<string, array{non-empty-string, (1|2|3)}>
|
||||
*/
|
||||
public function getClauses()
|
||||
{
|
||||
// This is a cheap fix for `SELECT` statements that contain `UNION`.
|
||||
// The `ORDER BY` and `LIMIT` clauses should be at the end of the
|
||||
// statement.
|
||||
if (! empty($this->union)) {
|
||||
$clauses = static::$CLAUSES;
|
||||
unset($clauses['ORDER BY'], $clauses['LIMIT']);
|
||||
$clauses['ORDER BY'] = [
|
||||
'ORDER BY',
|
||||
3,
|
||||
];
|
||||
$clauses['LIMIT'] = [
|
||||
'LIMIT',
|
||||
3,
|
||||
];
|
||||
|
||||
return $clauses;
|
||||
}
|
||||
|
||||
return static::$CLAUSES;
|
||||
}
|
||||
}
|
||||
+116
@@ -0,0 +1,116 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Components\SetOperation;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* `SET` statement.
|
||||
*/
|
||||
class SetStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* The clauses of this statement, in order.
|
||||
*
|
||||
* @see Statement::$CLAUSES
|
||||
*
|
||||
* @var array<string, array<int, int|string>>
|
||||
* @psalm-var array<string, array{non-empty-string, (1|2|3)}>
|
||||
*/
|
||||
public static $CLAUSES = [
|
||||
'SET' => [
|
||||
'SET',
|
||||
3,
|
||||
],
|
||||
'_END_OPTIONS' => [
|
||||
'_END_OPTIONS',
|
||||
1,
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* Possible exceptions in SET statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'CHARSET' => [
|
||||
3,
|
||||
'var',
|
||||
],
|
||||
'CHARACTER SET' => [
|
||||
3,
|
||||
'var',
|
||||
],
|
||||
'NAMES' => [
|
||||
3,
|
||||
'var',
|
||||
],
|
||||
'PASSWORD' => [
|
||||
3,
|
||||
'expr',
|
||||
],
|
||||
'SESSION' => 3,
|
||||
'GLOBAL' => 3,
|
||||
'PERSIST' => 3,
|
||||
'PERSIST_ONLY' => 3,
|
||||
'@@SESSION' => 3,
|
||||
'@@GLOBAL' => 3,
|
||||
'@@PERSIST' => 3,
|
||||
'@@PERSIST_ONLY' => 3,
|
||||
];
|
||||
|
||||
/**
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $END_OPTIONS = [
|
||||
'COLLATE' => [
|
||||
1,
|
||||
'var',
|
||||
],
|
||||
'DEFAULT' => 1,
|
||||
];
|
||||
|
||||
/**
|
||||
* Options used in current statement.
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $options;
|
||||
|
||||
/**
|
||||
* The end options of this query.
|
||||
*
|
||||
* @see static::$END_OPTIONS
|
||||
*
|
||||
* @var OptionsArray|null
|
||||
*/
|
||||
public $end_options;
|
||||
|
||||
/**
|
||||
* The updated values.
|
||||
*
|
||||
* @var SetOperation[]|null
|
||||
*/
|
||||
public $set;
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$ret = 'SET ' . OptionsArray::build($this->options)
|
||||
. ' ' . SetOperation::build($this->set)
|
||||
. ' ' . OptionsArray::build($this->end_options);
|
||||
|
||||
return trim($ret);
|
||||
}
|
||||
}
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
/**
|
||||
* `SHOW` statement.
|
||||
*/
|
||||
class ShowStatement extends NotImplementedStatement
|
||||
{
|
||||
/**
|
||||
* Options of this statement.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'CREATE' => 1,
|
||||
'AUTHORS' => 2,
|
||||
'BINARY' => 2,
|
||||
'BINLOG' => 2,
|
||||
'CHARACTER' => 2,
|
||||
'CODE' => 2,
|
||||
'COLLATION' => 2,
|
||||
'COLUMNS' => 2,
|
||||
'CONTRIBUTORS' => 2,
|
||||
'DATABASE' => 2,
|
||||
'DATABASES' => 2,
|
||||
'ENGINE' => 2,
|
||||
'ENGINES' => 2,
|
||||
'ERRORS' => 2,
|
||||
'EVENT' => 2,
|
||||
'EVENTS' => 2,
|
||||
'FUNCTION' => 2,
|
||||
'GRANTS' => 2,
|
||||
'HOSTS' => 2,
|
||||
'INDEX' => 2,
|
||||
'INNODB' => 2,
|
||||
'LOGS' => 2,
|
||||
'MASTER' => 2,
|
||||
'OPEN' => 2,
|
||||
'PLUGINS' => 2,
|
||||
'PRIVILEGES' => 2,
|
||||
'PROCEDURE' => 2,
|
||||
'PROCESSLIST' => 2,
|
||||
'PROFILE' => 2,
|
||||
'PROFILES' => 2,
|
||||
'SCHEDULER' => 2,
|
||||
'SET' => 2,
|
||||
'SLAVE' => 2,
|
||||
'STATUS' => 2,
|
||||
'TABLE' => 2,
|
||||
'TABLES' => 2,
|
||||
'TRIGGER' => 2,
|
||||
'TRIGGERS' => 2,
|
||||
'VARIABLES' => 2,
|
||||
'VIEW' => 2,
|
||||
'WARNINGS' => 2,
|
||||
];
|
||||
}
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
/**
|
||||
* Transaction statement.
|
||||
*/
|
||||
class TransactionStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* START TRANSACTION and BEGIN.
|
||||
*/
|
||||
public const TYPE_BEGIN = 1;
|
||||
|
||||
/**
|
||||
* COMMIT and ROLLBACK.
|
||||
*/
|
||||
public const TYPE_END = 2;
|
||||
|
||||
/**
|
||||
* The type of this query.
|
||||
*
|
||||
* @var int|null
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* The list of statements in this transaction.
|
||||
*
|
||||
* @var Statement[]|null
|
||||
*/
|
||||
public $statements;
|
||||
|
||||
/**
|
||||
* The ending transaction statement which may be a `COMMIT` or a `ROLLBACK`.
|
||||
*
|
||||
* @var TransactionStatement|null
|
||||
*/
|
||||
public $end;
|
||||
|
||||
/**
|
||||
* Options for this query.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'START TRANSACTION' => 1,
|
||||
'BEGIN' => 1,
|
||||
'COMMIT' => 1,
|
||||
'ROLLBACK' => 1,
|
||||
'WITH CONSISTENT SNAPSHOT' => 2,
|
||||
'WORK' => 2,
|
||||
'AND NO CHAIN' => 3,
|
||||
'AND CHAIN' => 3,
|
||||
'RELEASE' => 4,
|
||||
'NO RELEASE' => 4,
|
||||
];
|
||||
|
||||
/**
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param TokensList $list the list of tokens to be parsed
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function parse(Parser $parser, TokensList $list)
|
||||
{
|
||||
parent::parse($parser, $list);
|
||||
|
||||
// Checks the type of this query.
|
||||
if ($this->options->has('START TRANSACTION') || $this->options->has('BEGIN')) {
|
||||
$this->type = self::TYPE_BEGIN;
|
||||
} elseif ($this->options->has('COMMIT') || $this->options->has('ROLLBACK')) {
|
||||
$this->type = self::TYPE_END;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$ret = OptionsArray::build($this->options);
|
||||
if ($this->type === self::TYPE_BEGIN) {
|
||||
foreach ($this->statements as $statement) {
|
||||
/*
|
||||
* @var SelectStatement $statement
|
||||
*/
|
||||
$ret .= ';' . $statement->build();
|
||||
}
|
||||
|
||||
$ret .= ';';
|
||||
if ($this->end !== null) {
|
||||
$ret .= $this->end->build();
|
||||
}
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
}
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
|
||||
/**
|
||||
* `TRUNCATE` statement.
|
||||
*/
|
||||
class TruncateStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `TRUNCATE` statements.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = ['TABLE' => 1];
|
||||
|
||||
/**
|
||||
* The name of the truncated table.
|
||||
*
|
||||
* @var Expression|null
|
||||
*/
|
||||
public $table;
|
||||
|
||||
/**
|
||||
* Special build method for truncate statement as Statement::build would return empty string.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
return 'TRUNCATE TABLE ' . $this->table . ';';
|
||||
}
|
||||
}
|
||||
+163
@@ -0,0 +1,163 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Condition;
|
||||
use PhpMyAdmin\SqlParser\Components\Expression;
|
||||
use PhpMyAdmin\SqlParser\Components\JoinKeyword;
|
||||
use PhpMyAdmin\SqlParser\Components\Limit;
|
||||
use PhpMyAdmin\SqlParser\Components\OrderKeyword;
|
||||
use PhpMyAdmin\SqlParser\Components\SetOperation;
|
||||
use PhpMyAdmin\SqlParser\Exceptions\ParserException;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
|
||||
/**
|
||||
* `UPDATE` statement.
|
||||
*
|
||||
* UPDATE [LOW_PRIORITY] [IGNORE] table_reference
|
||||
* [INNER JOIN | LEFT JOIN | JOIN] T1 ON T1.C1 = T2.C1
|
||||
* SET col_name1={expr1|DEFAULT} [, col_name2={expr2|DEFAULT}] ...
|
||||
* [WHERE where_condition]
|
||||
* [ORDER BY ...]
|
||||
* [LIMIT row_count]
|
||||
*
|
||||
* or
|
||||
*
|
||||
* UPDATE [LOW_PRIORITY] [IGNORE] table_references
|
||||
* SET col_name1={expr1|DEFAULT} [, col_name2={expr2|DEFAULT}] ...
|
||||
* [WHERE where_condition]
|
||||
*/
|
||||
class UpdateStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `UPDATE` statements and their slot ID.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = [
|
||||
'LOW_PRIORITY' => 1,
|
||||
'IGNORE' => 2,
|
||||
];
|
||||
|
||||
/**
|
||||
* The clauses of this statement, in order.
|
||||
*
|
||||
* @see Statement::$CLAUSES
|
||||
*
|
||||
* @var array<string, array<int, int|string>>
|
||||
* @psalm-var array<string, array{non-empty-string, (1|2|3)}>
|
||||
*/
|
||||
public static $CLAUSES = [
|
||||
'UPDATE' => [
|
||||
'UPDATE',
|
||||
2,
|
||||
],
|
||||
// Used for options.
|
||||
'_OPTIONS' => [
|
||||
'_OPTIONS',
|
||||
1,
|
||||
],
|
||||
// Used for updated tables.
|
||||
'_UPDATE' => [
|
||||
'UPDATE',
|
||||
1,
|
||||
],
|
||||
'JOIN' => [
|
||||
'JOIN',
|
||||
1,
|
||||
],
|
||||
'LEFT JOIN' => [
|
||||
'LEFT JOIN',
|
||||
1,
|
||||
],
|
||||
'INNER JOIN' => [
|
||||
'INNER JOIN',
|
||||
1,
|
||||
],
|
||||
'SET' => [
|
||||
'SET',
|
||||
3,
|
||||
],
|
||||
'WHERE' => [
|
||||
'WHERE',
|
||||
3,
|
||||
],
|
||||
'ORDER BY' => [
|
||||
'ORDER BY',
|
||||
3,
|
||||
],
|
||||
'LIMIT' => [
|
||||
'LIMIT',
|
||||
3,
|
||||
],
|
||||
];
|
||||
|
||||
/**
|
||||
* Tables used as sources for this statement.
|
||||
*
|
||||
* @var Expression[]|null
|
||||
*/
|
||||
public $tables;
|
||||
|
||||
/**
|
||||
* The updated values.
|
||||
*
|
||||
* @var SetOperation[]|null
|
||||
*/
|
||||
public $set;
|
||||
|
||||
/**
|
||||
* Conditions used for filtering each row of the result set.
|
||||
*
|
||||
* @var Condition[]|null
|
||||
*/
|
||||
public $where;
|
||||
|
||||
/**
|
||||
* Specifies the order of the rows in the result set.
|
||||
*
|
||||
* @var OrderKeyword[]|null
|
||||
*/
|
||||
public $order;
|
||||
|
||||
/**
|
||||
* Conditions used for limiting the size of the result set.
|
||||
*
|
||||
* @var Limit|null
|
||||
*/
|
||||
public $limit;
|
||||
|
||||
/**
|
||||
* Joins.
|
||||
*
|
||||
* @var JoinKeyword[]|null
|
||||
*/
|
||||
public $join;
|
||||
|
||||
/**
|
||||
* Function called after the token was processed.
|
||||
* In the update statement, this is used to check that at least one assignment has been set to throw an error if a
|
||||
* query like `UPDATE acme SET WHERE 1;` is parsed.
|
||||
*
|
||||
* @return void
|
||||
*
|
||||
* @throws ParserException throws the exception, if strict mode is enabled.
|
||||
*/
|
||||
public function after(Parser $parser, TokensList $list, Token $token)
|
||||
{
|
||||
/** @psalm-var string $tokenValue */
|
||||
$tokenValue = $token->value;
|
||||
// Ensure we finished to parse the "SET" token, and if yes, ensure that assignments are defined.
|
||||
if ($this->set !== [] || (Parser::$KEYWORD_PARSERS[$tokenValue]['field'] ?? null) !== 'set') {
|
||||
return;
|
||||
}
|
||||
|
||||
$parser->error('Missing assignment in SET operation.', $list->tokens[$list->idx]);
|
||||
}
|
||||
}
|
||||
+343
@@ -0,0 +1,343 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Statements;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Components\Array2d;
|
||||
use PhpMyAdmin\SqlParser\Components\OptionsArray;
|
||||
use PhpMyAdmin\SqlParser\Components\WithKeyword;
|
||||
use PhpMyAdmin\SqlParser\Exceptions\ParserException;
|
||||
use PhpMyAdmin\SqlParser\Parser;
|
||||
use PhpMyAdmin\SqlParser\Statement;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
use PhpMyAdmin\SqlParser\TokensList;
|
||||
use PhpMyAdmin\SqlParser\Translator;
|
||||
|
||||
use function array_slice;
|
||||
use function count;
|
||||
use function preg_match;
|
||||
|
||||
/**
|
||||
* `WITH` statement.
|
||||
|
||||
* WITH [RECURSIVE] query_name [ (column_name [,...]) ] AS (SELECT ...) [, ...]
|
||||
*/
|
||||
final class WithStatement extends Statement
|
||||
{
|
||||
/**
|
||||
* Options for `WITH` statements and their slot ID.
|
||||
*
|
||||
* @var array<string, int|array<int, int|string>>
|
||||
* @psalm-var array<string, (positive-int|array{positive-int, ('var'|'var='|'expr'|'expr=')})>
|
||||
*/
|
||||
public static $OPTIONS = ['RECURSIVE' => 1];
|
||||
|
||||
/**
|
||||
* The clauses of this statement, in order.
|
||||
*
|
||||
* @see Statement::$CLAUSES
|
||||
*
|
||||
* @var array<string, array<int, int|string>>
|
||||
* @psalm-var array<string, array{non-empty-string, (1|2|3)}>
|
||||
*/
|
||||
public static $CLAUSES = [
|
||||
'WITH' => [
|
||||
'WITH',
|
||||
2,
|
||||
],
|
||||
// Used for options.
|
||||
'_OPTIONS' => [
|
||||
'_OPTIONS',
|
||||
1,
|
||||
],
|
||||
'AS' => [
|
||||
'AS',
|
||||
2,
|
||||
],
|
||||
];
|
||||
|
||||
/** @var WithKeyword[] */
|
||||
public $withers = [];
|
||||
|
||||
/**
|
||||
* holds the CTE parser.
|
||||
*
|
||||
* @var Parser|null
|
||||
*/
|
||||
public $cteStatementParser;
|
||||
|
||||
/**
|
||||
* @param Parser $parser the instance that requests parsing
|
||||
* @param TokensList $list the list of tokens to be parsed
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function parse(Parser $parser, TokensList $list)
|
||||
{
|
||||
/**
|
||||
* The state of the parser.
|
||||
*
|
||||
* Below are the states of the parser.
|
||||
*
|
||||
* 0 ---------------- [ name ] -----------------> 1
|
||||
*
|
||||
* 1 ------------------ [ ( ] ------------------> 2
|
||||
*
|
||||
* 2 ------------------ [ AS ] -----------------> 3
|
||||
*
|
||||
* 3 ------------------ [ ( ] ------------------> 4
|
||||
*
|
||||
* 4 ------------------ [ , ] ------------------> 1
|
||||
*
|
||||
* 4 ----- [ SELECT/UPDATE/DELETE/INSERT ] -----> 5
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
$state = 0;
|
||||
$wither = null;
|
||||
|
||||
++$list->idx; // Skipping `WITH`.
|
||||
|
||||
// parse any options if provided
|
||||
$this->options = OptionsArray::parse($parser, $list, static::$OPTIONS);
|
||||
++$list->idx;
|
||||
|
||||
for (; $list->idx < $list->count; ++$list->idx) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
// Skipping whitespaces and comments.
|
||||
if ($token->type === Token::TYPE_WHITESPACE || $token->type === Token::TYPE_COMMENT) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ($state === 0) {
|
||||
if ($token->type !== Token::TYPE_NONE || ! preg_match('/^[a-zA-Z0-9_$]+$/', $token->token)) {
|
||||
$parser->error('The name of the CTE was expected.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$wither = $token->value;
|
||||
$this->withers[$wither] = new WithKeyword($wither);
|
||||
$state = 1;
|
||||
} elseif ($state === 1) {
|
||||
if ($token->type === Token::TYPE_OPERATOR && $token->value === '(') {
|
||||
$columns = Array2d::parse($parser, $list);
|
||||
if ($parser->errors !== []) {
|
||||
break;
|
||||
}
|
||||
|
||||
$this->withers[$wither]->columns = $columns;
|
||||
$state = 2;
|
||||
} elseif ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'AS') {
|
||||
$state = 3;
|
||||
} else {
|
||||
$parser->error('Unexpected token.', $token);
|
||||
break;
|
||||
}
|
||||
} elseif ($state === 2) {
|
||||
if (! ($token->type === Token::TYPE_KEYWORD && $token->keyword === 'AS')) {
|
||||
$parser->error('AS keyword was expected.', $token);
|
||||
break;
|
||||
}
|
||||
|
||||
$state = 3;
|
||||
} elseif ($state === 3) {
|
||||
$idxBeforeGetNext = $list->idx;
|
||||
|
||||
$list->idx++; // Ignore the current token
|
||||
$nextKeyword = $list->getNext();
|
||||
|
||||
if (! ($token->value === '(' && ($nextKeyword && $nextKeyword->value === 'SELECT'))) {
|
||||
$parser->error('Subquery of the CTE was expected.', $token);
|
||||
$list->idx = $idxBeforeGetNext;
|
||||
break;
|
||||
}
|
||||
|
||||
// Restore the index
|
||||
$list->idx = $idxBeforeGetNext;
|
||||
|
||||
++$list->idx;
|
||||
$subList = $this->getSubTokenList($list);
|
||||
if ($subList instanceof ParserException) {
|
||||
$parser->errors[] = $subList;
|
||||
break;
|
||||
}
|
||||
|
||||
$subParser = new Parser($subList);
|
||||
|
||||
if (count($subParser->errors)) {
|
||||
foreach ($subParser->errors as $error) {
|
||||
$parser->errors[] = $error;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
$this->withers[$wither]->statement = $subParser;
|
||||
|
||||
$state = 4;
|
||||
} elseif ($state === 4) {
|
||||
if ($token->value === ',') {
|
||||
// There's another WITH expression to parse, go back to state=0
|
||||
$state = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (
|
||||
$token->type === Token::TYPE_KEYWORD && (
|
||||
$token->value === 'SELECT'
|
||||
|| $token->value === 'INSERT'
|
||||
|| $token->value === 'UPDATE'
|
||||
|| $token->value === 'DELETE'
|
||||
)
|
||||
) {
|
||||
$state = 5;
|
||||
--$list->idx;
|
||||
continue;
|
||||
}
|
||||
|
||||
$parser->error('An expression was expected.', $token);
|
||||
break;
|
||||
} elseif ($state === 5) {
|
||||
/**
|
||||
* We need to parse all of the remaining tokens becuase mostly, they are only the CTE expression
|
||||
* which's mostly is SELECT, or INSERT, UPDATE, or delete statement.
|
||||
* e.g: INSERT .. ( SELECT 1 ) SELECT col1 FROM cte ON DUPLICATE KEY UPDATE col_name = 3.
|
||||
* The issue is that, `ON DUPLICATE KEY UPDATE col_name = 3` is related to the main INSERT query
|
||||
* not the cte expression (SELECT col1 FROM cte) we need to determine the end of the expression
|
||||
* to parse `ON DUPLICATE KEY UPDATE` from the InsertStatement parser instead.
|
||||
*/
|
||||
|
||||
// Index of the last parsed token by default would be the last token in the $list, because we're
|
||||
// assuming that all remaining tokens at state 4, are related to the expression.
|
||||
$idxOfLastParsedToken = $list->count - 1;
|
||||
// Index before search to be able to restore the index.
|
||||
$idxBeforeSearch = $list->idx;
|
||||
// Length of expression tokens is null by default, in order for the $subList to start
|
||||
// from $list->idx to the end of the $list.
|
||||
$lengthOfExpressionTokens = null;
|
||||
|
||||
if ($list->getNextOfTypeAndValue(Token::TYPE_KEYWORD, 'ON')) {
|
||||
// (-1) because getNextOfTypeAndValue returned ON and increased the index.
|
||||
$idxOfOn = $list->idx - 1;
|
||||
// We want to make sure that it's `ON DUPLICATE KEY UPDATE`
|
||||
$dubplicateToken = $list->getNext();
|
||||
$keyToken = $list->getNext();
|
||||
$updateToken = $list->getNext();
|
||||
if (
|
||||
$dubplicateToken && $dubplicateToken->keyword === 'DUPLICATE'
|
||||
&& ($keyToken && $keyToken->keyword === 'KEY')
|
||||
&& ($updateToken && $updateToken->keyword === 'UPDATE')
|
||||
) {
|
||||
// Index of the last parsed token will be the token before the ON Keyword
|
||||
$idxOfLastParsedToken = $idxOfOn - 1;
|
||||
// The length of the expression tokens would be the difference
|
||||
// between the first unrelated token `ON` and the idx
|
||||
// before skipping the CTE tokens.
|
||||
$lengthOfExpressionTokens = $idxOfOn - $idxBeforeSearch;
|
||||
}
|
||||
}
|
||||
|
||||
// Restore the index
|
||||
$list->idx = $idxBeforeSearch;
|
||||
|
||||
$subList = new TokensList(array_slice($list->tokens, $list->idx, $lengthOfExpressionTokens));
|
||||
$subParser = new Parser($subList);
|
||||
if (count($subParser->errors)) {
|
||||
foreach ($subParser->errors as $error) {
|
||||
$parser->errors[] = $error;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
$this->cteStatementParser = $subParser;
|
||||
|
||||
$list->idx = $idxOfLastParsedToken;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// 5 is the only valid end state
|
||||
if ($state !== 5) {
|
||||
/**
|
||||
* Token parsed at this moment.
|
||||
*/
|
||||
$token = $list->tokens[$list->idx];
|
||||
|
||||
$parser->error('Unexpected end of the WITH CTE.', $token);
|
||||
}
|
||||
|
||||
--$list->idx;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public function build()
|
||||
{
|
||||
$str = 'WITH ';
|
||||
|
||||
foreach ($this->withers as $wither) {
|
||||
$str .= $str === 'WITH ' ? '' : ', ';
|
||||
$str .= WithKeyword::build($wither);
|
||||
}
|
||||
|
||||
$str .= ' ';
|
||||
|
||||
if ($this->cteStatementParser) {
|
||||
foreach ($this->cteStatementParser->statements as $statement) {
|
||||
$str .= $statement->build();
|
||||
}
|
||||
}
|
||||
|
||||
return $str;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get tokens within the WITH expression to use them in another parser
|
||||
*
|
||||
* @return ParserException|TokensList
|
||||
*/
|
||||
private function getSubTokenList(TokensList $list)
|
||||
{
|
||||
$idx = $list->idx;
|
||||
$token = $list->tokens[$list->idx];
|
||||
$openParenthesis = 0;
|
||||
|
||||
while ($list->idx < $list->count) {
|
||||
if ($token->value === '(') {
|
||||
++$openParenthesis;
|
||||
} elseif ($token->value === ')') {
|
||||
if (--$openParenthesis === -1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
++$list->idx;
|
||||
if (! isset($list->tokens[$list->idx])) {
|
||||
break;
|
||||
}
|
||||
|
||||
$token = $list->tokens[$list->idx];
|
||||
}
|
||||
|
||||
// performance improvement: return the error to avoid a try/catch in the loop
|
||||
if ($list->idx === $list->count) {
|
||||
--$list->idx;
|
||||
|
||||
return new ParserException(
|
||||
Translator::gettext('A closing bracket was expected.'),
|
||||
$token
|
||||
);
|
||||
}
|
||||
|
||||
$length = $list->idx - $idx;
|
||||
|
||||
return new TokensList(array_slice($list->tokens, $idx, $length), $length);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,344 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser;
|
||||
|
||||
use function hexdec;
|
||||
use function mb_strlen;
|
||||
use function mb_substr;
|
||||
use function str_replace;
|
||||
use function stripcslashes;
|
||||
use function strtoupper;
|
||||
|
||||
/**
|
||||
* Defines a token along with a set of types and flags and utility functions.
|
||||
*
|
||||
* An array of tokens will result after parsing the query.
|
||||
*
|
||||
* A structure representing a lexeme that explicitly indicates its categorization for the purpose of parsing.
|
||||
*/
|
||||
class Token
|
||||
{
|
||||
// Types of tokens (a vague description of a token's purpose).
|
||||
|
||||
/**
|
||||
* This type is used when the token is invalid or its type cannot be
|
||||
* determined because of the ambiguous context. Further analysis might be
|
||||
* required to detect its type.
|
||||
*/
|
||||
public const TYPE_NONE = 0;
|
||||
|
||||
/**
|
||||
* SQL specific keywords: SELECT, UPDATE, INSERT, etc.
|
||||
*/
|
||||
public const TYPE_KEYWORD = 1;
|
||||
|
||||
/**
|
||||
* Any type of legal operator.
|
||||
*
|
||||
* Arithmetic operators: +, -, *, /, etc.
|
||||
* Logical operators: ===, <>, !==, etc.
|
||||
* Bitwise operators: &, |, ^, etc.
|
||||
* Assignment operators: =, +=, -=, etc.
|
||||
* SQL specific operators: . (e.g. .. WHERE database.table ..),
|
||||
* * (e.g. SELECT * FROM ..)
|
||||
*/
|
||||
public const TYPE_OPERATOR = 2;
|
||||
|
||||
/**
|
||||
* Spaces, tabs, new lines, etc.
|
||||
*/
|
||||
public const TYPE_WHITESPACE = 3;
|
||||
|
||||
/**
|
||||
* Any type of legal comment.
|
||||
*
|
||||
* Bash (#), C (/* *\/) or SQL (--) comments:
|
||||
*
|
||||
* -- SQL-comment
|
||||
*
|
||||
* #Bash-like comment
|
||||
*
|
||||
* /*C-like comment*\/
|
||||
*
|
||||
* or:
|
||||
*
|
||||
* /*C-like
|
||||
* comment*\/
|
||||
*
|
||||
* Backslashes were added to respect PHP's comments syntax.
|
||||
*/
|
||||
public const TYPE_COMMENT = 4;
|
||||
|
||||
/**
|
||||
* Boolean values: true or false.
|
||||
*/
|
||||
public const TYPE_BOOL = 5;
|
||||
|
||||
/**
|
||||
* Numbers: 4, 0x8, 15.16, 23e42, etc.
|
||||
*/
|
||||
public const TYPE_NUMBER = 6;
|
||||
|
||||
/**
|
||||
* Literal strings: 'string', "test".
|
||||
* Some of these strings are actually symbols.
|
||||
*/
|
||||
public const TYPE_STRING = 7;
|
||||
|
||||
/**
|
||||
* Database, table names, variables, etc.
|
||||
* For example: ```SELECT `foo`, `bar` FROM `database`.`table`;```.
|
||||
*/
|
||||
public const TYPE_SYMBOL = 8;
|
||||
|
||||
/**
|
||||
* Delimits an unknown string.
|
||||
* For example: ```SELECT * FROM test;```, `test` is a delimiter.
|
||||
*/
|
||||
public const TYPE_DELIMITER = 9;
|
||||
|
||||
/**
|
||||
* Labels in LOOP statement, ITERATE statement etc.
|
||||
* For example (only for begin label):
|
||||
* begin_label: BEGIN [statement_list] END [end_label]
|
||||
* begin_label: LOOP [statement_list] END LOOP [end_label]
|
||||
* begin_label: REPEAT [statement_list] ... END REPEAT [end_label]
|
||||
* begin_label: WHILE ... DO [statement_list] END WHILE [end_label].
|
||||
*/
|
||||
public const TYPE_LABEL = 10;
|
||||
|
||||
/**
|
||||
* All tokens types
|
||||
*/
|
||||
public const TYPE_ALL = [
|
||||
self::TYPE_NONE,
|
||||
self::TYPE_KEYWORD,
|
||||
self::TYPE_OPERATOR,
|
||||
self::TYPE_WHITESPACE,
|
||||
self::TYPE_COMMENT,
|
||||
self::TYPE_BOOL,
|
||||
self::TYPE_NUMBER,
|
||||
self::TYPE_STRING,
|
||||
self::TYPE_SYMBOL,
|
||||
self::TYPE_DELIMITER,
|
||||
self::TYPE_LABEL,
|
||||
];
|
||||
|
||||
// Flags that describe the tokens in more detail.
|
||||
// All keywords must have flag 1 so `Context::isKeyword` method doesn't
|
||||
// require strict comparison.
|
||||
public const FLAG_KEYWORD = 1;
|
||||
public const FLAG_KEYWORD_RESERVED = 2;
|
||||
public const FLAG_KEYWORD_COMPOSED = 4;
|
||||
public const FLAG_KEYWORD_DATA_TYPE = 8;
|
||||
public const FLAG_KEYWORD_KEY = 16;
|
||||
public const FLAG_KEYWORD_FUNCTION = 32;
|
||||
|
||||
// Numbers related flags.
|
||||
public const FLAG_NUMBER_HEX = 1;
|
||||
public const FLAG_NUMBER_FLOAT = 2;
|
||||
public const FLAG_NUMBER_APPROXIMATE = 4;
|
||||
public const FLAG_NUMBER_NEGATIVE = 8;
|
||||
public const FLAG_NUMBER_BINARY = 16;
|
||||
|
||||
// Strings related flags.
|
||||
public const FLAG_STRING_SINGLE_QUOTES = 1;
|
||||
public const FLAG_STRING_DOUBLE_QUOTES = 2;
|
||||
|
||||
// Comments related flags.
|
||||
public const FLAG_COMMENT_BASH = 1;
|
||||
public const FLAG_COMMENT_C = 2;
|
||||
public const FLAG_COMMENT_SQL = 4;
|
||||
public const FLAG_COMMENT_MYSQL_CMD = 8;
|
||||
|
||||
// Operators related flags.
|
||||
public const FLAG_OPERATOR_ARITHMETIC = 1;
|
||||
public const FLAG_OPERATOR_LOGICAL = 2;
|
||||
public const FLAG_OPERATOR_BITWISE = 4;
|
||||
public const FLAG_OPERATOR_ASSIGNMENT = 8;
|
||||
public const FLAG_OPERATOR_SQL = 16;
|
||||
|
||||
// Symbols related flags.
|
||||
public const FLAG_SYMBOL_VARIABLE = 1;
|
||||
public const FLAG_SYMBOL_BACKTICK = 2;
|
||||
public const FLAG_SYMBOL_USER = 4;
|
||||
public const FLAG_SYMBOL_SYSTEM = 8;
|
||||
public const FLAG_SYMBOL_PARAMETER = 16;
|
||||
|
||||
/**
|
||||
* The token it its raw string representation.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
public $token;
|
||||
|
||||
/**
|
||||
* The value this token contains (i.e. token after some evaluation).
|
||||
*
|
||||
* @var mixed
|
||||
*/
|
||||
public $value;
|
||||
|
||||
/**
|
||||
* The keyword value this token contains, always uppercase.
|
||||
*
|
||||
* @var mixed|string|null
|
||||
*/
|
||||
public $keyword;
|
||||
|
||||
/**
|
||||
* The type of this token.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
public $type;
|
||||
|
||||
/**
|
||||
* The flags of this token.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
public $flags;
|
||||
|
||||
/**
|
||||
* The position in the initial string where this token started.
|
||||
*
|
||||
* The position is counted in chars, not bytes, so you should
|
||||
* use mb_* functions to properly handle utf-8 multibyte chars.
|
||||
*
|
||||
* @var int|null
|
||||
*/
|
||||
public $position;
|
||||
|
||||
/**
|
||||
* @param string $token the value of the token
|
||||
* @param int $type the type of the token
|
||||
* @param int $flags the flags of the token
|
||||
*/
|
||||
public function __construct($token, $type = 0, $flags = 0)
|
||||
{
|
||||
$this->token = $token;
|
||||
$this->type = $type;
|
||||
$this->flags = $flags;
|
||||
$this->keyword = null;
|
||||
$this->value = $this->extract();
|
||||
}
|
||||
|
||||
/**
|
||||
* Does little processing to the token to extract a value.
|
||||
*
|
||||
* If no processing can be done it will return the initial string.
|
||||
*
|
||||
* @return mixed
|
||||
*/
|
||||
public function extract()
|
||||
{
|
||||
switch ($this->type) {
|
||||
case self::TYPE_KEYWORD:
|
||||
$this->keyword = strtoupper($this->token);
|
||||
if (! ($this->flags & self::FLAG_KEYWORD_RESERVED)) {
|
||||
// Unreserved keywords should stay the way they are because they
|
||||
// might represent field names.
|
||||
return $this->token;
|
||||
}
|
||||
|
||||
return $this->keyword;
|
||||
|
||||
case self::TYPE_WHITESPACE:
|
||||
return ' ';
|
||||
|
||||
case self::TYPE_BOOL:
|
||||
return strtoupper($this->token) === 'TRUE';
|
||||
|
||||
case self::TYPE_NUMBER:
|
||||
$ret = str_replace('--', '', $this->token); // e.g. ---42 === -42
|
||||
if ($this->flags & self::FLAG_NUMBER_HEX) {
|
||||
$ret = str_replace(['-', '+'], '', $this->token);
|
||||
if ($this->flags & self::FLAG_NUMBER_NEGATIVE) {
|
||||
$ret = -hexdec($ret);
|
||||
} else {
|
||||
$ret = hexdec($ret);
|
||||
}
|
||||
} elseif (($this->flags & self::FLAG_NUMBER_APPROXIMATE) || ($this->flags & self::FLAG_NUMBER_FLOAT)) {
|
||||
$ret = (float) $ret;
|
||||
} elseif (! ($this->flags & self::FLAG_NUMBER_BINARY)) {
|
||||
$ret = (int) $ret;
|
||||
}
|
||||
|
||||
return $ret;
|
||||
|
||||
case self::TYPE_STRING:
|
||||
// Trims quotes.
|
||||
$str = $this->token;
|
||||
$str = mb_substr($str, 1, -1, 'UTF-8');
|
||||
|
||||
// Removes surrounding quotes.
|
||||
$quote = $this->token[0];
|
||||
$str = str_replace($quote . $quote, $quote, $str);
|
||||
|
||||
// Finally unescapes the string.
|
||||
//
|
||||
// `stripcslashes` replaces escape sequences with their
|
||||
// representation.
|
||||
//
|
||||
// NOTE: In MySQL, `\f` and `\v` have no representation,
|
||||
// even they usually represent: form-feed and vertical tab.
|
||||
$str = str_replace('\f', 'f', $str);
|
||||
$str = str_replace('\v', 'v', $str);
|
||||
$str = stripcslashes($str);
|
||||
|
||||
return $str;
|
||||
|
||||
case self::TYPE_SYMBOL:
|
||||
$str = $this->token;
|
||||
if (isset($str[0]) && ($str[0] === '@')) {
|
||||
// `mb_strlen($str)` must be used instead of `null` because
|
||||
// in PHP 5.3- the `null` parameter isn't handled correctly.
|
||||
$str = mb_substr(
|
||||
$str,
|
||||
! empty($str[1]) && ($str[1] === '@') ? 2 : 1,
|
||||
mb_strlen($str),
|
||||
'UTF-8'
|
||||
);
|
||||
}
|
||||
|
||||
if (isset($str[0]) && ($str[0] === ':')) {
|
||||
$str = mb_substr($str, 1, mb_strlen($str), 'UTF-8');
|
||||
}
|
||||
|
||||
if (isset($str[0]) && (($str[0] === '`') || ($str[0] === '"') || ($str[0] === '\''))) {
|
||||
$quote = $str[0];
|
||||
$str = mb_substr($str, 1, -1, 'UTF-8');
|
||||
$str = str_replace($quote . $quote, $quote, $str);
|
||||
}
|
||||
|
||||
return $str;
|
||||
}
|
||||
|
||||
return $this->token;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts the token into an inline token by replacing tabs and new lines.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function getInlineToken()
|
||||
{
|
||||
return str_replace(
|
||||
[
|
||||
"\r",
|
||||
"\n",
|
||||
"\t",
|
||||
],
|
||||
[
|
||||
'\r',
|
||||
'\n',
|
||||
'\t',
|
||||
],
|
||||
$this->token
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,282 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser;
|
||||
|
||||
use ArrayAccess;
|
||||
|
||||
use function array_splice;
|
||||
use function count;
|
||||
use function in_array;
|
||||
use function is_array;
|
||||
use function is_string;
|
||||
|
||||
/**
|
||||
* Defines an array of tokens and utility functions to iterate through it.
|
||||
*
|
||||
* A structure representing a list of tokens.
|
||||
*
|
||||
* @implements ArrayAccess<int, Token>
|
||||
*/
|
||||
class TokensList implements ArrayAccess
|
||||
{
|
||||
/**
|
||||
* The array of tokens.
|
||||
*
|
||||
* @var Token[]
|
||||
*/
|
||||
public $tokens = [];
|
||||
|
||||
/**
|
||||
* The count of tokens.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
public $count = 0;
|
||||
|
||||
/**
|
||||
* The index of the next token to be returned.
|
||||
*
|
||||
* @var int
|
||||
*/
|
||||
public $idx = 0;
|
||||
|
||||
/**
|
||||
* @param Token[] $tokens the initial array of tokens
|
||||
* @param int $count the count of tokens in the initial array
|
||||
*/
|
||||
public function __construct(array $tokens = [], $count = -1)
|
||||
{
|
||||
if (empty($tokens)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->tokens = $tokens;
|
||||
$this->count = $count === -1 ? count($tokens) : $count;
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds an array of tokens by merging their raw value.
|
||||
*
|
||||
* @param string|Token[]|TokensList $list the tokens to be built
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function build($list)
|
||||
{
|
||||
if (is_string($list)) {
|
||||
return $list;
|
||||
}
|
||||
|
||||
if ($list instanceof self) {
|
||||
$list = $list->tokens;
|
||||
}
|
||||
|
||||
$ret = '';
|
||||
if (is_array($list)) {
|
||||
foreach ($list as $tok) {
|
||||
$ret .= $tok->token;
|
||||
}
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a new token.
|
||||
*
|
||||
* @param Token $token token to be added in list
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function add(Token $token)
|
||||
{
|
||||
$this->tokens[$this->count++] = $token;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the next token. Skips any irrelevant token (whitespaces and
|
||||
* comments).
|
||||
*
|
||||
* @return Token|null
|
||||
*/
|
||||
public function getNext()
|
||||
{
|
||||
for (; $this->idx < $this->count; ++$this->idx) {
|
||||
if (
|
||||
($this->tokens[$this->idx]->type !== Token::TYPE_WHITESPACE)
|
||||
&& ($this->tokens[$this->idx]->type !== Token::TYPE_COMMENT)
|
||||
) {
|
||||
return $this->tokens[$this->idx++];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the previous token. Skips any irrelevant token (whitespaces and
|
||||
* comments).
|
||||
*/
|
||||
public function getPrevious(): ?Token
|
||||
{
|
||||
for (; $this->idx >= 0; --$this->idx) {
|
||||
if (
|
||||
($this->tokens[$this->idx]->type !== Token::TYPE_WHITESPACE)
|
||||
&& ($this->tokens[$this->idx]->type !== Token::TYPE_COMMENT)
|
||||
) {
|
||||
return $this->tokens[$this->idx--];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the previous token.
|
||||
*
|
||||
* @param int|int[] $type the type
|
||||
*
|
||||
* @return Token|null
|
||||
*/
|
||||
public function getPreviousOfType($type)
|
||||
{
|
||||
if (! is_array($type)) {
|
||||
$type = [$type];
|
||||
}
|
||||
|
||||
for (; $this->idx >= 0; --$this->idx) {
|
||||
if (in_array($this->tokens[$this->idx]->type, $type, true)) {
|
||||
return $this->tokens[$this->idx--];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the next token.
|
||||
*
|
||||
* @param int|int[] $type the type
|
||||
*
|
||||
* @return Token|null
|
||||
*/
|
||||
public function getNextOfType($type)
|
||||
{
|
||||
if (! is_array($type)) {
|
||||
$type = [$type];
|
||||
}
|
||||
|
||||
for (; $this->idx < $this->count; ++$this->idx) {
|
||||
if (in_array($this->tokens[$this->idx]->type, $type, true)) {
|
||||
return $this->tokens[$this->idx++];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the next token.
|
||||
*
|
||||
* @param int $type the type of the token
|
||||
* @param string $value the value of the token
|
||||
*
|
||||
* @return Token|null
|
||||
*/
|
||||
public function getNextOfTypeAndValue($type, $value)
|
||||
{
|
||||
for (; $this->idx < $this->count; ++$this->idx) {
|
||||
if (($this->tokens[$this->idx]->type === $type) && ($this->tokens[$this->idx]->value === $value)) {
|
||||
return $this->tokens[$this->idx++];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the next token.
|
||||
*
|
||||
* @param int $type the type of the token
|
||||
* @param int $flag the flag of the token
|
||||
*/
|
||||
public function getNextOfTypeAndFlag(int $type, int $flag): ?Token
|
||||
{
|
||||
for (; $this->idx < $this->count; ++$this->idx) {
|
||||
if (($this->tokens[$this->idx]->type === $type) && ($this->tokens[$this->idx]->flags === $flag)) {
|
||||
return $this->tokens[$this->idx++];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets a Token inside the list of tokens.
|
||||
* When defined, offset must be positive otherwise the offset is ignored.
|
||||
* If the offset is not defined (like in array_push) or if it is greater than the number of Tokens already stored,
|
||||
* the Token is appended to the list of tokens.
|
||||
*
|
||||
* @param int|null $offset the offset to be set. Must be positive otherwise, nothing will be stored.
|
||||
* @param Token $value the token to be saved
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
#[\ReturnTypeWillChange]
|
||||
public function offsetSet($offset, $value)
|
||||
{
|
||||
if ($offset === null || $offset >= $this->count) {
|
||||
$this->tokens[$this->count++] = $value;
|
||||
} elseif ($offset >= 0) {
|
||||
$this->tokens[$offset] = $value;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a Token from the list of tokens.
|
||||
* If the offset is negative or above the number of tokens set in the list, will return null.
|
||||
*
|
||||
* @param int $offset the offset to be returned
|
||||
*
|
||||
* @return Token|null
|
||||
*/
|
||||
#[\ReturnTypeWillChange]
|
||||
public function offsetGet($offset)
|
||||
{
|
||||
return $this->offsetExists($offset) ? $this->tokens[$offset] : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if an offset was previously set.
|
||||
* If the offset is negative or above the number of tokens set in the list, will return false.
|
||||
*
|
||||
* @param int $offset the offset to be checked
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
#[\ReturnTypeWillChange]
|
||||
public function offsetExists($offset)
|
||||
{
|
||||
return $offset >= 0 && $offset < $this->count;
|
||||
}
|
||||
|
||||
/**
|
||||
* Unsets the value of an offset, if the offset exists.
|
||||
*
|
||||
* @param int $offset the offset to be unset
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
#[\ReturnTypeWillChange]
|
||||
public function offsetUnset($offset)
|
||||
{
|
||||
if (! $this->offsetExists($offset)) {
|
||||
return;
|
||||
}
|
||||
|
||||
array_splice($this->tokens, $offset, 1);
|
||||
--$this->count;
|
||||
}
|
||||
}
|
||||
+412
@@ -0,0 +1,412 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Tools;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
|
||||
use function array_filter;
|
||||
use function array_map;
|
||||
use function array_merge;
|
||||
use function array_slice;
|
||||
use function basename;
|
||||
use function count;
|
||||
use function dirname;
|
||||
use function file;
|
||||
use function file_put_contents;
|
||||
use function implode;
|
||||
use function ksort;
|
||||
use function preg_match;
|
||||
use function scandir;
|
||||
use function sort;
|
||||
use function sprintf;
|
||||
use function str_replace;
|
||||
use function str_split;
|
||||
use function strlen;
|
||||
use function strstr;
|
||||
use function strtoupper;
|
||||
use function substr;
|
||||
use function trim;
|
||||
|
||||
use const ARRAY_FILTER_USE_KEY;
|
||||
use const SORT_STRING;
|
||||
|
||||
/**
|
||||
* Used for context generation.
|
||||
*/
|
||||
class ContextGenerator
|
||||
{
|
||||
/**
|
||||
* Labels and flags that may be used when defining keywords.
|
||||
*
|
||||
* @var array<string, int>
|
||||
*/
|
||||
public static $LABELS_FLAGS = [
|
||||
'(R)' => Token::FLAG_KEYWORD_RESERVED,
|
||||
'(D)' => Token::FLAG_KEYWORD_DATA_TYPE,
|
||||
'(K)' => Token::FLAG_KEYWORD_KEY,
|
||||
'(F)' => Token::FLAG_KEYWORD_FUNCTION,
|
||||
];
|
||||
|
||||
/**
|
||||
* Documentation links for each context.
|
||||
*
|
||||
* @var array<string, string>
|
||||
*/
|
||||
public static $LINKS = [
|
||||
'MySql50000' => 'https://dev.mysql.com/doc/refman/5.0/en/keywords.html',
|
||||
'MySql50100' => 'https://dev.mysql.com/doc/refman/5.1/en/keywords.html',
|
||||
'MySql50500' => 'https://dev.mysql.com/doc/refman/5.5/en/keywords.html',
|
||||
'MySql50600' => 'https://dev.mysql.com/doc/refman/5.6/en/keywords.html',
|
||||
'MySql50700' => 'https://dev.mysql.com/doc/refman/5.7/en/keywords.html',
|
||||
'MySql80000' => 'https://dev.mysql.com/doc/refman/8.0/en/keywords.html',
|
||||
'MySql80100' => 'https://dev.mysql.com/doc/refman/8.1/en/keywords.html',
|
||||
'MySql80200' => 'https://dev.mysql.com/doc/refman/8.2/en/keywords.html',
|
||||
'MySql80300' => 'https://dev.mysql.com/doc/refman/8.3/en/keywords.html',
|
||||
'MySql80400' => 'https://dev.mysql.com/doc/refman/8.4/en/keywords.html',
|
||||
'MySql90000' => 'https://dev.mysql.com/doc/refman/9.0/en/keywords.html',
|
||||
'MySql90100' => 'https://dev.mysql.com/doc/refman/9.1/en/keywords.html',
|
||||
'MariaDb100000' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb100100' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb100200' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb100300' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb100400' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb100500' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb100600' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb100700' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb100800' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb100900' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb101000' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb101100' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb110000' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb110100' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb110200' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb110300' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb110400' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb110500' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb110600' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
'MariaDb110700' => 'https://mariadb.com/kb/en/reserved-words/',
|
||||
];
|
||||
|
||||
/**
|
||||
* Reversed const <=> int from {@see Token} class to write the constant name instead of its value.
|
||||
*
|
||||
* @var array<int, string>
|
||||
*/
|
||||
private static $typesNumToConst = [
|
||||
1 => 'Token::FLAG_KEYWORD',
|
||||
2 => 'Token::FLAG_KEYWORD_RESERVED',
|
||||
4 => 'Token::FLAG_KEYWORD_COMPOSED',
|
||||
8 => 'Token::FLAG_KEYWORD_DATA_TYPE',
|
||||
16 => 'Token::FLAG_KEYWORD_KEY',
|
||||
32 => 'Token::FLAG_KEYWORD_FUNCTION',
|
||||
];
|
||||
|
||||
/**
|
||||
* The template of a context.
|
||||
*
|
||||
* Parameters:
|
||||
* 1 - name
|
||||
* 2 - class
|
||||
* 3 - link
|
||||
* 4 - keywords array
|
||||
*/
|
||||
public const TEMPLATE = <<<'PHP'
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Contexts;
|
||||
|
||||
use PhpMyAdmin\SqlParser\Context;
|
||||
use PhpMyAdmin\SqlParser\Token;
|
||||
|
||||
/**
|
||||
* Context for %1$s.
|
||||
*
|
||||
* This class was auto-generated from tools/contexts/*.txt.
|
||||
* Use tools/run_generators.sh for update.
|
||||
*
|
||||
* @see %3$s
|
||||
*/
|
||||
class %2$s extends Context
|
||||
{
|
||||
/**
|
||||
* List of keywords.
|
||||
*
|
||||
* The value associated to each keyword represents its flags.
|
||||
*
|
||||
* @see Token
|
||||
*
|
||||
* @var array<string,int>
|
||||
* @phpstan-var non-empty-array<non-empty-string,Token::FLAG_KEYWORD_*|int>
|
||||
*/
|
||||
public static $KEYWORDS = [
|
||||
%4$s ];
|
||||
}
|
||||
|
||||
PHP;
|
||||
|
||||
/**
|
||||
* Sorts an array of words.
|
||||
*
|
||||
* @param array<int, list<string>> $arr
|
||||
*
|
||||
* @return array<int, list<string>>
|
||||
*/
|
||||
public static function sortWords(array &$arr)
|
||||
{
|
||||
ksort($arr);
|
||||
foreach ($arr as &$words) {
|
||||
sort($words, SORT_STRING);
|
||||
}
|
||||
|
||||
return $arr;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads a list of words and sorts it by type, length and keyword.
|
||||
*
|
||||
* @param list<string> $files
|
||||
*
|
||||
* @return array<int, list<string>>
|
||||
*/
|
||||
public static function readWords(array $files)
|
||||
{
|
||||
/** @psalm-var list<string> $words */
|
||||
$words = [];
|
||||
foreach ($files as $file) {
|
||||
$words = array_merge($words, file($file));
|
||||
}
|
||||
|
||||
/** @var array<string, int> $types */
|
||||
$types = [];
|
||||
|
||||
for ($i = 0, $count = count($words); $i !== $count; ++$i) {
|
||||
$value = trim($words[$i]);
|
||||
if ($value === '') {
|
||||
continue;
|
||||
}
|
||||
|
||||
$type = Token::FLAG_KEYWORD;
|
||||
|
||||
// Reserved, data types, keys, functions, etc. keywords.
|
||||
foreach (static::$LABELS_FLAGS as $label => $flags) {
|
||||
if (strstr($value, $label) === false) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$type |= $flags;
|
||||
$value = trim(str_replace($label, '', $value));
|
||||
}
|
||||
|
||||
// Composed keyword.
|
||||
if (strstr($value, ' ') !== false) {
|
||||
$type |= Token::FLAG_KEYWORD_RESERVED;
|
||||
$type |= Token::FLAG_KEYWORD_COMPOSED;
|
||||
}
|
||||
|
||||
$value = strtoupper($value);
|
||||
if (! isset($types[$value])) {
|
||||
$types[$value] = $type;
|
||||
} else {
|
||||
$types[$value] |= $type;
|
||||
}
|
||||
}
|
||||
|
||||
// Prepare an array in a way to sort by type, then by word.
|
||||
$ret = [];
|
||||
foreach ($types as $word => $type) {
|
||||
$ret[$type][] = $word;
|
||||
}
|
||||
|
||||
return static::sortWords($ret);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prints an array of a words in PHP format.
|
||||
*
|
||||
* @param array<int, list<string>> $words the list of words to be formatted
|
||||
*/
|
||||
public static function printWords(array $words): string
|
||||
{
|
||||
$ret = '';
|
||||
foreach ($words as $type => $wordsByType) {
|
||||
foreach ($wordsByType as $word) {
|
||||
$ret .= sprintf(" '%s' => %s,\n", $word, self::translateIntTypeToTextConstant($type));
|
||||
}
|
||||
}
|
||||
|
||||
return $ret;
|
||||
}
|
||||
|
||||
private static function translateIntTypeToTextConstant(int $type): string
|
||||
{
|
||||
$matchingFlags = array_filter(
|
||||
self::$typesNumToConst,
|
||||
static function (int $num) use ($type): bool {
|
||||
return ($type & $num) !== 0;
|
||||
},
|
||||
ARRAY_FILTER_USE_KEY
|
||||
);
|
||||
|
||||
return implode(' | ', $matchingFlags);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a context's class.
|
||||
*
|
||||
* @param array<string, string|array<int, list<string>>> $options the options for this context
|
||||
* @psalm-param array{
|
||||
* name: string,
|
||||
* class: string,
|
||||
* link: string,
|
||||
* keywords: array<int, list<string>>
|
||||
* } $options
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function generate($options)
|
||||
{
|
||||
$options['keywords'] = static::printWords($options['keywords']);
|
||||
|
||||
return sprintf(self::TEMPLATE, $options['name'], $options['class'], $options['link'], $options['keywords']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats context name.
|
||||
*
|
||||
* @param string $name name to format
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function formatName($name)
|
||||
{
|
||||
/* Split name and version */
|
||||
$parts = [];
|
||||
if (preg_match('/^(\D+)(\d+)$/', $name, $parts) === 0) {
|
||||
return $name;
|
||||
}
|
||||
|
||||
/* Format name */
|
||||
$base = $parts[1];
|
||||
switch ($base) {
|
||||
case 'MySql':
|
||||
$base = 'MySQL';
|
||||
break;
|
||||
case 'MariaDb':
|
||||
$base = 'MariaDB';
|
||||
break;
|
||||
}
|
||||
|
||||
/* Parse version to array */
|
||||
$versionString = $parts[2];
|
||||
if (strlen($versionString) % 2 === 1) {
|
||||
$versionString = '0' . $versionString;
|
||||
}
|
||||
|
||||
$version = array_map('intval', str_split($versionString, 2));
|
||||
/* Remove trailing zero */
|
||||
if ($version[count($version) - 1] === 0) {
|
||||
$version = array_slice($version, 0, -1);
|
||||
}
|
||||
|
||||
/* Create name */
|
||||
return $base . ' ' . implode('.', $version);
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds a test.
|
||||
*
|
||||
* Reads the input file, generates the data and writes it back.
|
||||
*
|
||||
* @param string $input the input file
|
||||
* @param string $output the output directory
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function build($input, $output)
|
||||
{
|
||||
/**
|
||||
* The directory that contains the input file.
|
||||
*
|
||||
* Used to include common files.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$directory = dirname($input) . '/';
|
||||
|
||||
/**
|
||||
* The name of the file that contains the context.
|
||||
*/
|
||||
$file = basename($input);
|
||||
|
||||
/**
|
||||
* The name of the context.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$name = substr($file, 0, -4);
|
||||
|
||||
/**
|
||||
* The name of the class that defines this context.
|
||||
*
|
||||
* @var string
|
||||
*/
|
||||
$class = 'Context' . $name;
|
||||
|
||||
/**
|
||||
* The formatted name of this context.
|
||||
*/
|
||||
$formattedName = static::formatName($name);
|
||||
|
||||
file_put_contents(
|
||||
$output . '/' . $class . '.php',
|
||||
static::generate(
|
||||
[
|
||||
'name' => $formattedName,
|
||||
'class' => $class,
|
||||
'link' => static::$LINKS[$name],
|
||||
'keywords' => static::readWords(
|
||||
[
|
||||
$directory . '_common.txt',
|
||||
$directory . '_functions' . $file,
|
||||
$directory . $file,
|
||||
]
|
||||
),
|
||||
]
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates recursively all tests preserving the directory structure.
|
||||
*
|
||||
* @param string $input the input directory
|
||||
* @param string $output the output directory
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function buildAll($input, $output)
|
||||
{
|
||||
$files = scandir($input);
|
||||
|
||||
foreach ($files as $file) {
|
||||
// Skipping current and parent directories.
|
||||
// Skipping _functions* and _common.txt files
|
||||
if (($file[0] === '.') || ($file[0] === '_')) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Skipping README.md
|
||||
if ($file === 'README.md') {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Building the context.
|
||||
echo sprintf("Building context for %s...\n", $file);
|
||||
static::build($input . '/' . $file, $output);
|
||||
}
|
||||
}
|
||||
}
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace PhpMyAdmin\SqlParser\Tools;
|
||||
|
||||
use ReflectionClass;
|
||||
use ReflectionException;
|
||||
use Zumba\JsonSerializer\JsonSerializer;
|
||||
|
||||
use function in_array;
|
||||
|
||||
/**
|
||||
* Used for .out files generation
|
||||
*/
|
||||
class CustomJsonSerializer extends JsonSerializer
|
||||
{
|
||||
public const SKIP_PROPERTIES = [
|
||||
'ALLOWED_KEYWORDS',
|
||||
'GROUP_OPTIONS',
|
||||
'END_OPTIONS',
|
||||
'KEYWORD_PARSERS',
|
||||
'STATEMENT_PARSERS',
|
||||
'KEYWORD_NAME_INDICATORS',
|
||||
'OPERATOR_NAME_INDICATORS',
|
||||
'DEFAULT_DELIMITER',
|
||||
'PARSER_METHODS',
|
||||
'OPTIONS',
|
||||
'CLAUSES',
|
||||
'DB_OPTIONS',
|
||||
'DELIMITERS',
|
||||
'JOINS',
|
||||
'FIELDS_OPTIONS',
|
||||
'LINES_OPTIONS',
|
||||
'TRIGGER_OPTIONS',
|
||||
'FUNC_OPTIONS',
|
||||
'TABLE_OPTIONS',
|
||||
'FIELD_OPTIONS',
|
||||
'DATA_TYPE_OPTIONS',
|
||||
'REFERENCES_OPTIONS',
|
||||
'KEY_OPTIONS',
|
||||
'VIEW_OPTIONS',
|
||||
'EVENT_OPTIONS',
|
||||
'USER_OPTIONS',
|
||||
'asciiMap',
|
||||
];
|
||||
|
||||
/**
|
||||
* Extract the object data
|
||||
*
|
||||
* @param object $value
|
||||
* @param ReflectionClass $ref
|
||||
* @param string[] $properties
|
||||
*
|
||||
* @return array<string,mixed>
|
||||
*/
|
||||
protected function extractObjectData($value, $ref, $properties)
|
||||
{
|
||||
$data = [];
|
||||
foreach ($properties as $property) {
|
||||
if (in_array($property, self::SKIP_PROPERTIES, true)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
try {
|
||||
$propRef = $ref->getProperty($property);
|
||||
$propRef->setAccessible(true);
|
||||
$data[$property] = $propRef->getValue($value);
|
||||
} catch (ReflectionException $e) {
|
||||
$data[$property] = $value->$property;
|
||||
}
|
||||
}
|
||||
|
||||
return $data;
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user