This is an automated email from the ASF dual-hosted git repository.
morrysnow pushed a commit to branch 2.0.1-rc04-patch
in repository https://gitbox.apache.org/repos/asf/doris.git
commit c019309d9b4a8b1e86001ff711d563b514146928
Author: morrySnow <morrys...@126.com>
AuthorDate: Mon Sep 11 13:55:33 2023 +0800
[opt](Nereids) let keywords list same with legacy planner
---
.../antlr4/org/apache/doris/nereids/DorisLexer.g4 | 360 +++++++++++------
.../antlr4/org/apache/doris/nereids/DorisParser.g4 | 432 +++++++++++----------
.../doris/nereids/parser/LogicalPlanBuilder.java | 18 +-
.../org/apache/doris/nereids/types/DataType.java | 12 +-
4 files changed, 493 insertions(+), 329 deletions(-)
diff --git a/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisLexer.g4
b/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisLexer.g4
index dee87743bb..34ce6f3a4b 100644
--- a/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisLexer.g4
+++ b/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisLexer.g4
@@ -89,322 +89,445 @@ RIGHT_BRACKET: ']';
// Start of the keywords list
//============================
//--DORIS-KEYWORD-LIST-START
+ACCOUNT_LOCK: 'ACCOUNT_LOCK';
+ACCOUNT_UNLOCK: 'ACCOUNT_UNLOCK';
ADD: 'ADD';
ADDDATE:'ADDDATE';
+ADMIN: 'ADMIN';
AFTER: 'AFTER';
+AGG_STATE: 'AGG_STATE';
+AGGREGATE: 'AGGREGATE';
+ALIAS: 'ALIAS';
ALL: 'ALL';
ALTER: 'ALTER';
ANALYZE: 'ANALYZE';
ANALYZED: 'ANALYZED';
AND: 'AND';
ANTI: 'ANTI';
-ANY: 'ANY';
-ARCHIVE: 'ARCHIVE';
+APPEND: 'APPEND';
ARRAY: 'ARRAY';
AS: 'AS';
ASC: 'ASC';
AT: 'AT';
-AUTHORIZATION: 'AUTHORIZATION';
-AVG: 'AVG';
+AUTHORS: 'AUTHORS';
+AUTO: 'AUTO';
+AUTO_INCREMENT: 'AUTO_INCREMENT';
+BACKEND: 'BACKEND';
+BACKENDS: 'BACKENDS';
+BACKUP: 'BACKUP';
+BEGIN: 'BEGIN';
BETWEEN: 'BETWEEN';
+BIGINT: 'BIGINT';
+BIN: 'BIN';
+BINLOG: 'BINLOG';
BITAND: 'BITAND';
+BITMAP: 'BITMAP';
+BITMAP_UNION: 'BITMAP_UNION';
BITOR: 'BITOR';
BITXOR: 'BITXOR';
-BOTH: 'BOTH';
-BUCKET: 'BUCKET';
+BLOB: 'BLOB';
+BOOLEAN: 'BOOLEAN';
+BRIEF: 'BRIEF';
+BROKER: 'BROKER';
BUCKETS: 'BUCKETS';
+BUILD: 'BUILD';
+BUILTIN: 'BUILTIN';
BY: 'BY';
-CACHE: 'CACHE';
-CASCADE: 'CASCADE';
+CACHED: 'CACHED';
+CANCEL: 'CANCEL';
CASE: 'CASE';
CAST: 'CAST';
CATALOG: 'CATALOG';
CATALOGS: 'CATALOGS';
-CHANGE: 'CHANGE';
+CHAIN: 'CHAIN';
+CHAR: 'CHAR' | 'CHARACTER';
+CHARSET: 'CHARSET';
CHECK: 'CHECK';
-CLEAR: 'CLEAR';
+CLEAN: 'CLEAN';
CLUSTER: 'CLUSTER';
-CLUSTERED: 'CLUSTERED';
-CODEGEN: 'CODEGEN';
+CLUSTERS: 'CLUSTERS';
COLLATE: 'COLLATE';
-COLLECTION: 'COLLECTION';
+COLLATION: 'COLLATION';
COLUMN: 'COLUMN';
COLUMNS: 'COLUMNS';
COMMENT: 'COMMENT';
COMMIT: 'COMMIT';
+COMMITTED: 'COMMITTED';
COMPACT: 'COMPACT';
-COMPACTIONS: 'COMPACTIONS';
-COMPUTE: 'COMPUTE';
-CONCATENATE: 'CONCATENATE';
-CONSTRAINT: 'CONSTRAINT';
-COST: 'COST';
+COMPLETE: 'COMPLETE';
+CONFIG: 'CONFIG';
+CONNECTION: 'CONNECTION';
+CONNECTION_ID: 'CONNECTION_ID';
+CONSISTENT: 'CONSISTENT';
+CONVERT: 'CONVERT';
+COPY: 'COPY';
+COUNT: 'COUNT';
CREATE: 'CREATE';
+CREATION: 'CREATION';
+CRON: 'CRON';
CROSS: 'CROSS';
CUBE: 'CUBE';
CURRENT: 'CURRENT';
-CURRENT_DATE: 'CURRENT_DATE';
-CURRENT_TIME: 'CURRENT_TIME';
+CURRENT_CATALOG: 'CURRENT_CATALOG';
CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP';
CURRENT_USER: 'CURRENT_USER';
-DAY: 'DAY';
-DAYS_ADD: 'DAYS_ADD';
-DAYS_SUB: 'DAYS_SUB';
DATA: 'DATA';
DATABASE: 'DATABASE';
DATABASES: 'DATABASES';
DATE: 'DATE';
-DATEADD: 'DATEADD';
-DATEDIFF: 'DATEDIFF';
DATE_ADD: 'DATE_ADD';
-DATE_SUB: 'DATE_SUB';
+DATE_CEIL: 'DATE_CEIL';
DATE_DIFF: 'DATE_DIFF';
-DBPROPERTIES: 'DBPROPERTIES';
+DATE_FLOOR: 'DATE_FLOOR';
+DATE_SUB: 'DATE_SUB';
+DATEADD: 'DATEADD';
+DATEDIFF: 'DATEDIFF';
+DATETIME: 'DATETIME';
+DATETIMEV2: 'DATETIMEV2';
+DATEV2: 'DATEV2';
+DAY: 'DAY';
+DAYS_ADD: 'DAYS_ADD';
+DAYS_SUB: 'DAYS_SUB';
+DECIMAL: 'DECIMAL';
+DECIMALV3: 'DECIMALV3';
+DECOMMISSION: 'DECOMMISSION';
DEFAULT: 'DEFAULT';
-DEFINED: 'DEFINED';
+DEFERRED: 'DEFERRED';
DELETE: 'DELETE';
-DELIMITED: 'DELIMITED';
+DEMAND: 'DEMAND';
DESC: 'DESC';
DESCRIBE: 'DESCRIBE';
-DFS: 'DFS';
-DIRECTORIES: 'DIRECTORIES';
-DIRECTORY: 'DIRECTORY';
+DIAGNOSE: 'DIAGNOSE';
+DISK: 'DISK';
DISTINCT: 'DISTINCT';
-DISTRIBUTE: 'DISTRIBUTE';
+DISTINCTPC: 'DISTINCTPC';
+DISTINCTPCSA: 'DISTINCTPCSA';
+DISTRIBUTED: 'DISTRIBUTED';
+DISTRIBUTION: 'DISTRIBUTION';
DIV: 'DIV';
+DO: 'DO';
+DOUBLE: 'DOUBLE';
DROP: 'DROP';
+DROPP: 'DROPP';
+DUPLICATE: 'DUPLICATE';
+DYNAMIC: 'DYNAMIC';
ELSE: 'ELSE';
+ENABLE: 'ENABLE';
+ENCRYPTKEY: 'ENCRYPTKEY';
+ENCRYPTKEYS: 'ENCRYPTKEYS';
END: 'END';
-ESCAPE: 'ESCAPE';
-ESCAPED: 'ESCAPED';
+ENDS: 'ENDS';
+ENGINE: 'ENGINE';
+ENGINES: 'ENGINES';
+ENTER: 'ENTER';
+ERRORS: 'ERRORS';
+EVENTS: 'EVENTS';
+EVERY: 'EVERY';
EXCEPT: 'EXCEPT';
-EXCHANGE: 'EXCHANGE';
+EXCLUDE: 'EXCLUDE';
+EXECUTE: 'EXECUTE';
EXISTS: 'EXISTS';
+EXPIRED: 'EXPIRED';
EXPLAIN: 'EXPLAIN';
EXPORT: 'EXPORT';
EXTENDED: 'EXTENDED';
EXTERNAL: 'EXTERNAL';
EXTRACT: 'EXTRACT';
+FAILED_LOGIN_ATTEMPTS: 'FAILED_LOGIN_ATTEMPTS';
FALSE: 'FALSE';
-FETCH: 'FETCH';
+FAST: 'FAST';
+FEATURE: 'FEATURE';
FIELDS: 'FIELDS';
+FILE: 'FILE';
FILTER: 'FILTER';
-FILEFORMAT: 'FILEFORMAT';
FIRST: 'FIRST';
+FLOAT: 'FLOAT';
+FOLLOWER: 'FOLLOWER';
FOLLOWING: 'FOLLOWING';
FOR: 'FOR';
-FOREIGN: 'FOREIGN';
+FORCE: 'FORCE';
FORMAT: 'FORMAT';
-FORMATTED: 'FORMATTED';
+FREE: 'FREE';
FROM: 'FROM';
+FRONTEND: 'FRONTEND';
+FRONTENDS: 'FRONTENDS';
FULL: 'FULL';
FUNCTION: 'FUNCTION';
FUNCTIONS: 'FUNCTIONS';
GLOBAL: 'GLOBAL';
GRANT: 'GRANT';
+GRANTS: 'GRANTS';
GRAPH: 'GRAPH';
GROUP: 'GROUP';
GROUPING: 'GROUPING';
+GROUPS: 'GROUPS';
+HASH: 'HASH';
HAVING: 'HAVING';
+HDFS: 'HDFS';
+HELP: 'HELP';
+HISTOGRAM: 'HISTOGRAM';
+HLL: 'HLL';
+HLL_UNION: 'HLL_UNION';
+HOSTNAME: 'HOSTNAME';
HOUR: 'HOUR';
+HUB: 'HUB';
+IDENTIFIED: 'IDENTIFIED';
IF: 'IF';
IGNORE: 'IGNORE';
-IMPORT: 'IMPORT';
+IMMEDIATE: 'IMMEDIATE';
IN: 'IN';
+INCREMENTAL: 'INCREMENTAL';
INDEX: 'INDEX';
INDEXES: 'INDEXES';
+INFILE: 'INFILE';
INNER: 'INNER';
-INPATH: 'INPATH';
-INPUTFORMAT: 'INPUTFORMAT';
INSERT: 'INSERT';
+INSTALL: 'INSTALL';
+INT: 'INT';
+INTEGER: 'INTEGER';
+INTERMEDIATE: 'INTERMEDIATE';
INTERSECT: 'INTERSECT';
INTERVAL: 'INTERVAL';
INTO: 'INTO';
+INVERTED: 'INVERTED';
IS: 'IS';
-ISNULL: 'ISNULL';
-IS_NULL_PRED: 'IS_NULL_PRED';
IS_NOT_NULL_PRED: 'IS_NOT_NULL_PRED';
-ITEMS: 'ITEMS';
+IS_NULL_PRED: 'IS_NULL_PRED';
+ISNULL: 'ISNULL';
+ISOLATION: 'ISOLATION';
+JOB: 'JOB';
+JOBS: 'JOBS';
JOIN: 'JOIN';
+JSON: 'JSON';
+JSONB: 'JSONB';
+KEY: 'KEY';
KEYS: 'KEYS';
+KILL: 'KILL';
LABEL: 'LABEL';
+LARGEINT: 'LARGEINT';
LAST: 'LAST';
LATERAL: 'LATERAL';
-LAZY: 'LAZY';
-LEADING: 'LEADING';
+LDAP: 'LDAP';
+LDAP_ADMIN_PASSWORD: 'LDAP_ADMIN_PASSWORD';
LEFT: 'LEFT';
+LESS: 'LESS';
+LEVEL: 'LEVEL';
LIKE: 'LIKE';
-ILIKE: 'ILIKE';
LIMIT: 'LIMIT';
-OFFSET: 'OFFSET';
LINES: 'LINES';
+LINK: 'LINK';
LIST: 'LIST';
LOAD: 'LOAD';
LOCAL: 'LOCAL';
LOCATION: 'LOCATION';
LOCK: 'LOCK';
-LOCKS: 'LOCKS';
LOGICAL: 'LOGICAL';
-MACRO: 'MACRO';
+LOW_PRIORITY: 'LOW_PRIORITY';
MAP: 'MAP';
MATCH: 'MATCH';
-MATCH_ANY: 'MATCH_ANY';
MATCH_ALL: 'MATCH_ALL';
+MATCH_ANY: 'MATCH_ANY';
+MATCH_ELEMENT_EQ: 'ELEMENT_EQ';
+MATCH_ELEMENT_GE: 'ELEMENT_GE';
+MATCH_ELEMENT_GT: 'ELEMENT_GT';
+MATCH_ELEMENT_LE: 'ELEMENT_LE';
+MATCH_ELEMENT_LT: 'ELEMENT_LT';
MATCH_PHRASE: 'MATCH_PHRASE';
-MATCHED: 'MATCHED';
+MATERIALIZED: 'MATERIALIZED';
+MAX: 'MAX';
+MAX_VALUE: 'MAXVALUE';
MEMO:'MEMO';
MERGE: 'MERGE';
+MIGRATE: 'MIGRATE';
+MIGRATIONS: 'MIGRATIONS';
+MIN: 'MIN';
+MINUS: 'MINUS';
MINUTE: 'MINUTE';
+MODIFY: 'MODIFY';
MONTH: 'MONTH';
-MSCK: 'MSCK';
-NAMESPACE: 'NAMESPACE';
-NAMESPACES: 'NAMESPACES';
+MTMV: 'MTMV';
+NAME: 'NAME';
+NAMES: 'NAMES';
NATURAL: 'NATURAL';
+NEGATIVE: 'NEGATIVE';
+NEVER: 'NEVER';
+NEXT: 'NEXT';
+NGRAM_BF: 'NGRAM_BF';
NO: 'NO';
-NOT: 'NOT' | '!';
+NOT: 'NOT';
NULL: 'NULL';
NULLS: 'NULLS';
+OBSERVER: 'OBSERVER';
OF: 'OF';
+OFFSET: 'OFFSET';
ON: 'ON';
ONLY: 'ONLY';
+OPEN: 'OPEN';
OPTIMIZED: 'OPTIMIZED';
-OPTION: 'OPTION';
-OPTIONS: 'OPTIONS';
OR: 'OR';
ORDER: 'ORDER';
-OUT: 'OUT';
OUTER: 'OUTER';
OUTFILE: 'OUTFILE';
-OUTPUTFORMAT: 'OUTPUTFORMAT';
OVER: 'OVER';
-OVERLAPS: 'OVERLAPS';
-OVERLAY: 'OVERLAY';
OVERWRITE: 'OVERWRITE';
+PARAMETER: 'PARAMETER';
PARSED: 'PARSED';
PARTITION: 'PARTITION';
-PARTITIONED: 'PARTITIONED';
PARTITIONS: 'PARTITIONS';
-PERCENTILE_CONT: 'PERCENTILE_CONT';
-PERCENTLIT: 'PERCENT';
+PASSWORD: 'PASSWORD';
+PASSWORD_EXPIRE: 'PASSWORD_EXPIRE';
+PASSWORD_HISTORY: 'PASSWORD_HISTORY';
+PASSWORD_LOCK_TIME: 'PASSWORD_LOCK_TIME';
+PASSWORD_REUSE: 'PASSWORD_REUSE';
+PATH: 'PATH';
+PAUSE: 'PAUSE';
+PERCENT: 'PERCENT';
+PERIOD: 'PERIOD';
PERMISSIVE: 'PERMISSIVE';
PHYSICAL: 'PHYSICAL';
-PIVOT: 'PIVOT';
-PLACING: 'PLACING';
PLAN: 'PLAN';
+PLUGIN: 'PLUGIN';
+PLUGINS: 'PLUGINS';
POLICY: 'POLICY';
-POSITION: 'POSITION';
PRECEDING: 'PRECEDING';
-PRIMARY: 'PRIMARY';
-PRINCIPALS: 'PRINCIPALS';
+PREPARE: 'PREPARE';
+PROC: 'PROC';
+PROCEDURE: 'PROCEDURE';
+PROCESSLIST: 'PROCESSLIST';
+PROFILE: 'PROFILE';
PROPERTIES: 'PROPERTIES';
-PURGE: 'PURGE';
+PROPERTY: 'PROPERTY';
+QUANTILE_STATE: 'QUANTILE_STATE';
+QUANTILE_UNION: 'QUANTILE_UNION';
QUERY: 'QUERY';
+QUOTA: 'QUOTA';
+RANDOM: 'RANDOM';
RANGE: 'RANGE';
-RECORDREADER: 'RECORDREADER';
-RECORDWRITER: 'RECORDWRITER';
+READ: 'READ';
+REAL: 'REAL';
+REBALANCE: 'REBALANCE';
RECOVER: 'RECOVER';
-REDUCE: 'REDUCE';
-REFERENCES: 'REFERENCES';
+RECYCLE: 'RECYCLE';
REFRESH: 'REFRESH';
REGEXP: 'REGEXP';
+RELEASE: 'RELEASE';
RENAME: 'RENAME';
REPAIR: 'REPAIR';
REPEATABLE: 'REPEATABLE';
REPLACE: 'REPLACE';
-RESET: 'RESET';
-RESPECT: 'RESPECT';
-RESTRICT: 'RESTRICT';
+REPLACE_IF_NOT_NULL: 'REPLACE_IF_NOT_NULL';
+REPLICA: 'REPLICA';
+REPOSITORIES: 'REPOSITORIES';
+REPOSITORY: 'REPOSITORY';
+RESOURCE: 'RESOURCE';
+RESOURCES: 'RESOURCES';
+RESTORE: 'RESTORE';
RESTRICTIVE: 'RESTRICTIVE';
+RESUME: 'RESUME';
+RETURNS: 'RETURNS';
REVOKE: 'REVOKE';
REWRITTEN: 'REWRITTEN';
RIGHT: 'RIGHT';
-// original optimizer only support REGEXP, the new optimizer should be
consistent with it
RLIKE: 'RLIKE';
ROLE: 'ROLE';
ROLES: 'ROLES';
ROLLBACK: 'ROLLBACK';
ROLLUP: 'ROLLUP';
+ROUTINE: 'ROUTINE';
ROW: 'ROW';
ROWS: 'ROWS';
-SECOND: 'SECOND';
+S3: 'S3';
+SAMPLE: 'SAMPLE';
+SCHEDULER: 'SCHEDULER';
SCHEMA: 'SCHEMA';
SCHEMAS: 'SCHEMAS';
+SECOND: 'SECOND';
SELECT: 'SELECT';
SEMI: 'SEMI';
-SEPARATED: 'SEPARATED';
-SERDE: 'SERDE';
-SERDEPROPERTIES: 'SERDEPROPERTIES';
+SERIALIZABLE: 'SERIALIZABLE';
SESSION: 'SESSION';
-SESSION_USER: 'SESSION_USER';
SET: 'SET';
-SETMINUS: 'MINUS';
SETS: 'SETS';
SHAPE: 'SHAPE';
SHOW: 'SHOW';
-SKEWED: 'SKEWED';
-SOME: 'SOME';
-SORT: 'SORT';
-SORTED: 'SORTED';
+SIGNED: 'SIGNED';
+SKEW: 'SKEW';
+SMALLINT: 'SMALLINT';
+SNAPSHOT: 'SNAPSHOT';
+SONAME: 'SONAME';
+SPLIT: 'SPLIT';
+SQL_BLOCK_RULE: 'SQL_BLOCK_RULE';
START: 'START';
-STATISTICS: 'STATISTICS';
+STARTS: 'STARTS';
+STATS: 'STATS';
+STATUS: 'STATUS';
+STOP: 'STOP';
STORAGE: 'STORAGE';
-STORED: 'STORED';
-STRATIFY: 'STRATIFY';
+STREAM: 'STREAM';
+STREAMING: 'STREAMING';
+STRING: 'STRING';
STRUCT: 'STRUCT';
SUBDATE: 'SUBDATE';
+SUM: 'SUM';
+SUPERUSER: 'SUPERUSER';
+SWITCH: 'SWITCH';
SYNC: 'SYNC';
-SYSTEM_TIME: 'SYSTEM_TIME';
-SYSTEM_VERSION: 'SYSTEM_VERSION';
+SYSTEM: 'SYSTEM';
TABLE: 'TABLE';
TABLES: 'TABLES';
TABLESAMPLE: 'TABLESAMPLE';
-TBLPROPERTIES: 'TBLPROPERTIES';
-TEMPORARY: 'TEMPORARY' | 'TEMP';
+TABLET: 'TABLET';
+TABLETS: 'TABLETS';
+TASK: 'TASK';
+TASKS: 'TASKS';
+TEMPORARY: 'TEMPORARY';
TERMINATED: 'TERMINATED';
+TEXT: 'TEXT';
+THAN: 'THAN';
THEN: 'THEN';
TIME: 'TIME';
TIMESTAMP: 'TIMESTAMP';
TIMESTAMPADD: 'TIMESTAMPADD';
TIMESTAMPDIFF: 'TIMESTAMPDIFF';
+TINYINT: 'TINYINT';
TO: 'TO';
-TOUCH: 'TOUCH';
-TRAILING: 'TRAILING';
TRANSACTION: 'TRANSACTION';
-TRANSACTIONS: 'TRANSACTIONS';
-TRANSFORM: 'TRANSFORM';
+TRASH: 'TRASH';
+TRIGGERS: 'TRIGGERS';
TRIM: 'TRIM';
TRUE: 'TRUE';
TRUNCATE: 'TRUNCATE';
-TRY_CAST: 'TRY_CAST';
TYPE: 'TYPE';
-UNARCHIVE: 'UNARCHIVE';
+TYPECAST: 'TYPE_CAST';
+TYPES: 'TYPES';
UNBOUNDED: 'UNBOUNDED';
-UNCACHE: 'UNCACHE';
+UNCOMMITTED: 'UNCOMMITTED';
+UNINSTALL: 'UNINSTALL';
UNION: 'UNION';
UNIQUE: 'UNIQUE';
-UNKNOWN: 'UNKNOWN';
UNLOCK: 'UNLOCK';
-UNSET: 'UNSET';
+UNSIGNED: 'UNSIGNED';
UPDATE: 'UPDATE';
USE: 'USE';
USER: 'USER';
USING: 'USING';
+VALUE: 'VALUE';
VALUES: 'VALUES';
+VARCHAR: 'VARCHAR';
+VARIABLES: 'VARIABLES';
VERBOSE: 'VERBOSE';
VERSION: 'VERSION';
VIEW: 'VIEW';
-VIEWS: 'VIEWS';
+WARNINGS: 'WARNINGS';
WEEK: 'WEEK';
WHEN: 'WHEN';
WHERE: 'WHERE';
-WINDOW: 'WINDOW';
+WHITELIST: 'WHITELIST';
WITH: 'WITH';
-WITHIN: 'WITHIN';
+WORK: 'WORK';
+WORKLOAD: 'WORKLOAD';
+WRITE: 'WRITE';
YEAR: 'YEAR';
-ZONE: 'ZONE';
-DATEV2: 'DATEV2';
-S3: 'S3';
-HDFS: 'HDFS';
-BROKER: 'BROKER';
//--DORIS-KEYWORD-LIST-END
//============================
// End of the keywords list
@@ -419,13 +542,14 @@ GT : '>';
GTE : '>=' | '!<';
PLUS: '+';
-MINUS: '-';
+SUBTRACT: '-';
ASTERISK: '*';
SLASH: '/';
-PERCENT: '%';
+MOD: '%';
TILDE: '~';
AMPERSAND: '&';
LOGICALAND: '&&';
+LOGICALNOT: '!';
PIPE: '|';
DOUBLEPIPES: '||';
HAT: '^';
@@ -436,7 +560,7 @@ HINT_END: '*/';
ATSIGN: '@';
DOUBLEATSIGN: '@@';
-STRING
+STRING_LITERAL
: '\'' ( ~('\''|'\\') | ('\\' .) )* '\''
| '"' ( ~('"'|'\\') | ('\\' .) )* '"'
| 'R\'' (~'\'')* '\''
diff --git a/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisParser.g4
b/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisParser.g4
index 03e6fa0ace..363b5b0e35 100644
--- a/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisParser.g4
+++ b/fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisParser.g4
@@ -59,7 +59,7 @@ statement
identifierOrText
: errorCapturingIdentifier
- | STRING
+ | STRING_LITERAL
;
userIdentify
@@ -323,7 +323,7 @@ expression
;
booleanExpression
- : NOT booleanExpression
#logicalNot
+ : (LOGICALNOT | NOT) booleanExpression
#logicalNot
| EXISTS LEFT_PAREN query RIGHT_PAREN
#exist
| (ISNULL | IS_NULL_PRED) LEFT_PAREN valueExpression RIGHT_PAREN
#isnull
| IS_NOT_NULL_PRED LEFT_PAREN valueExpression RIGHT_PAREN
#is_not_null_pred
@@ -344,9 +344,9 @@ predicate
valueExpression
: primaryExpression
#valueExpressionDefault
- | operator=(MINUS | PLUS | TILDE) valueExpression
#arithmeticUnary
- | left=valueExpression operator=(ASTERISK | SLASH | PERCENT)
right=valueExpression #arithmeticBinary
- | left=valueExpression operator=(PLUS | MINUS | DIV | HAT | PIPE |
AMPERSAND)
+ | operator=(SUBTRACT | PLUS | TILDE) valueExpression
#arithmeticUnary
+ | left=valueExpression operator=(ASTERISK | SLASH | MOD)
right=valueExpression #arithmeticBinary
+ | left=valueExpression operator=(PLUS | SUBTRACT | DIV | HAT | PIPE |
AMPERSAND)
right=valueExpression
#arithmeticBinary
| left=valueExpression comparisonOperator right=valueExpression
#comparison
| operator=(BITAND | BITOR | BITXOR) LEFT_PAREN left = valueExpression
@@ -410,6 +410,20 @@ functionIdentifier
functionNameIdentifier
: identifier
| LEFT | RIGHT
+ | ADD
+ | CONNECTION_ID
+ | CURRENT_CATALOG
+ | CURRENT_USER
+ | DATABASE
+ | IF
+ | LEFT
+ | LIKE
+ | PASSWORD
+ | REGEXP
+ | RIGHT
+ | SCHEMA
+ | TRIM
+ | USER
;
windowSpec
@@ -451,10 +465,10 @@ specifiedPartition
constant
: NULL
#nullLiteral
| interval
#intervalLiteral
- | type=(DATE | DATEV2 | TIMESTAMP) STRING
#typeConstructor
+ | type=(DATE | DATEV2 | TIMESTAMP) STRING_LITERAL
#typeConstructor
| number
#numericLiteral
| booleanValue
#booleanLiteral
- | STRING
#stringLiteral
+ | STRING_LITERAL
#stringLiteral
;
comparisonOperator
@@ -478,8 +492,37 @@ unitIdentifier
;
dataType
- : identifier (LEFT_PAREN INTEGER_VALUE
- (COMMA INTEGER_VALUE)* RIGHT_PAREN)?
#primitiveDataType
+ : primitiveColType (LEFT_PAREN (INTEGER_VALUE | ASTERISK)
+ (COMMA INTEGER_VALUE)* RIGHT_PAREN)?
#primitiveDataType
+ ;
+
+primitiveColType:
+ | type=TINYINT
+ | type=SMALLINT
+ | (SIGNED | UNSIGNED)? type=INT
+ | type=BIGINT
+ | type=LARGEINT
+ | type=BOOLEAN
+ | type=FLOAT
+ | type=DOUBLE
+ | type=DATE
+ | type=DATETIME
+ | type=TIME
+ | type=DATEV2
+ | type=DATETIMEV2
+ | type=BITMAP
+ | type=QUANTILE_STATE
+ | type=HLL
+ | type=AGG_STATE
+ | type=STRING
+ | type=JSON
+ | type=JSONB
+ | type=TEXT
+ | type=VARCHAR
+ | type=CHAR
+ | type=DECIMAL
+ | type=DECIMALV3
+ | type=ALL
;
// this rule is used for explicitly capturing wrong identifiers such as
test-table, which should actually be `test-table`
@@ -491,7 +534,7 @@ errorCapturingIdentifier
// extra left-factoring grammar
errorCapturingIdentifierExtra
- : (MINUS identifier)+ #errorIdent
+ : (SUBTRACT identifier)+ #errorIdent
| #realIdent
;
@@ -510,8 +553,8 @@ quotedIdentifier
;
number
- : MINUS? INTEGER_VALUE #integerLiteral
- | MINUS? (EXPONENT_VALUE | DECIMAL_VALUE) #decimalLiteral
+ : SUBTRACT? INTEGER_VALUE #integerLiteral
+ | SUBTRACT? (EXPONENT_VALUE | DECIMAL_VALUE) #decimalLiteral
;
// there are 1 kinds of keywords in Doris.
@@ -521,278 +564,267 @@ number
// TODO: need to stay consistent with the legacy
nonReserved
//--DEFAULT-NON-RESERVED-START
- : ADD
+ : ADDDATE
| AFTER
- | ALL
- | ALTER
- | ANALYZE
+ | AGG_STATE
+ | AGGREGATE
+ | ALIAS
| ANALYZED
- | AND
- | ANY
- | ARCHIVE
| ARRAY
- | ASC
| AT
- | AUTHORIZATION
- | AVG
- | BETWEEN
- | BOTH
- | BUCKET
+ | AUTHORS
+ | BACKENDS
+ | BACKUP
+ | BEGIN
+ | BIN
+ | BITAND
+ | BITMAP
+ | BITMAP_UNION
+ | BITOR
+ | BITXOR
+ | BLOB
+ | BOOLEAN
+ | BRIEF
+ | BROKER
| BUCKETS
- | BY
- | CACHE
- | CASCADE
- | CASE
- | CAST
+ | BUILD
+ | BUILTIN
+ | CACHED
| CATALOG
| CATALOGS
- | CHANGE
+ | CHAIN
+ | CHAR
+ | CHARSET
| CHECK
- | CLEAR
| CLUSTER
- | CLUSTERED
- | CODEGEN
- | COLLATE
- | COLLECTION
- | COLUMN
+ | CLUSTERS
+ | COLLATION
| COLUMNS
| COMMENT
| COMMIT
+ | COMMITTED
| COMPACT
- | COMPACTIONS
- | COMPUTE
- | CONCATENATE
- | CONSTRAINT
- | COST
- | CREATE
- | CUBE
- | CURRENT
- | CURRENT_DATE
- | CURRENT_TIME
+ | COMPLETE
+ | CONFIG
+ | CONNECTION
+ | CONNECTION_ID
+ | CONSISTENT
+ | CONVERT
+ | COPY
+ | COUNT
+ | CREATION
+ | CRON
+ | CURRENT_CATALOG
| CURRENT_TIMESTAMP
- | CURRENT_USER
| DATA
- | DATABASE
- | DATABASES
| DATE
- | DATEV2
| DATE_ADD
- | DATEDIFF
+ | DATE_CEIL
| DATE_DIFF
+ | DATE_FLOOR
+ | DATE_SUB
+ | DATEADD
+ | DATEDIFF
+ | DATETIME
+ | DATETIMEV2
+ | DATEV2
| DAY
- | DBPROPERTIES
- | DEFINED
- | DELETE
- | DELIMITED
- | DESC
- | DESCRIBE
- | DFS
- | DIRECTORIES
- | DIRECTORY
- | DISTINCT
- | DISTRIBUTE
- | DIV
- | DROP
- | ELSE
+ | DAYS_ADD
+ | DAYS_SUB
+ | DECIMAL
+ | DECIMALV3
+ | DEFERRED
+ | DEMAND
+ | DIAGNOSE
+ | DISTINCTPC
+ | DISTINCTPCSA
+ | DO
+ | DYNAMIC
+ | ENABLE
+ | ENCRYPTKEY
+ | ENCRYPTKEYS
| END
- | ESCAPE
- | ESCAPED
- | EXCHANGE
- | EXISTS
- | EXPLAIN
- | EXPORT
- | EXTENDED
+ | ENDS
+ | ENGINE
+ | ENGINES
+ | ERRORS
+ | EVENTS
+ | EVERY
+ | EXCLUDE
+ | EXPIRED
| EXTERNAL
- | EXTRACT
- | FALSE
- | FETCH
- | FILTER
+ | FAILED_LOGIN_ATTEMPTS
+ | FAST
+ | FEATURE
| FIELDS
- | FILEFORMAT
+ | FILE
+ | FILTER
| FIRST
- | FOLLOWING
- | FOR
- | FOREIGN
| FORMAT
- | FORMATTED
- | FROM
+ | FREE
+ | FRONTENDS
| FUNCTION
- | FUNCTIONS
| GLOBAL
- | GRANT
| GRAPH
- | GROUP
| GROUPING
- | HAVING
+ | GROUPS
+ | HASH
+ | HDFS
+ | HELP
+ | HISTOGRAM
+ | HLL_UNION
+ | HOSTNAME
| HOUR
- | IF
+ | HUB
+ | IDENTIFIED
| IGNORE
- | IMPORT
- | IN
- | INDEX
+ | IMMEDIATE
+ | INCREMENTAL
| INDEXES
- | INPATH
- | INPUTFORMAT
- | INSERT
- | INTERVAL
- | INTO
- | IS
- | ITEMS
- | KEYS
+ | INVERTED
+ | IS_NOT_NULL_PRED
+ | IS_NULL_PRED
+ | ISNULL
+ | ISOLATION
+ | JOB
+ | JOBS
+ | JSON
+ | JSONB
| LABEL
| LAST
- | LAZY
- | LEADING
- | LIKE
- | ILIKE
- | LIMIT
+ | LDAP
+ | LDAP_ADMIN_PASSWORD
+ | LESS
+ | LEVEL
| LINES
- | LIST
- | LOAD
+ | LINK
| LOCAL
| LOCATION
| LOCK
- | LOCKS
| LOGICAL
- | MACRO
| MAP
- | MATCHED
+ | MATERIALIZED
+ | MAX
+ | MEMO
| MERGE
+ | MIGRATE
+ | MIGRATIONS
+ | MIN
| MINUTE
+ | MODIFY
| MONTH
- | MSCK
- | NAMESPACE
- | NAMESPACES
+ | MTMV
+ | NAME
+ | NAMES
+ | NEGATIVE
+ | NEVER
+ | NEXT
+ | NGRAM_BF
| NO
- | NOT
- | NULL
| NULLS
| OF
+ | OFFSET
| ONLY
+ | OPEN
| OPTIMIZED
- | OPTION
- | OPTIONS
- | OR
- | ORDER
- | OUT
- | OUTER
- | OUTPUTFORMAT
- | OVERLAPS
- | OVERLAY
- | OVERWRITE
+ | PARAMETER
| PARSED
- | PARTITION
- | PARTITIONED
| PARTITIONS
- | PERCENTILE_CONT
- | PERCENTLIT
+ | PASSWORD
+ | PASSWORD_EXPIRE
+ | PASSWORD_HISTORY
+ | PASSWORD_LOCK_TIME
+ | PASSWORD_REUSE
+ | PATH
+ | PAUSE
+ | PERCENT
+ | PERIOD
| PERMISSIVE
| PHYSICAL
- | PIVOT
- | PLACING
| PLAN
+ | PLUGIN
+ | PLUGINS
| POLICY
- | POSITION
- | PRECEDING
- | PRIMARY
- | PRINCIPALS
+ | PROC
+ | PROCESSLIST
+ | PROFILE
| PROPERTIES
- | PURGE
+ | PROPERTY
+ | QUANTILE_STATE
+ | QUANTILE_UNION
| QUERY
- | RANGE
- | RECORDREADER
- | RECORDWRITER
+ | QUOTA
+ | RANDOM
| RECOVER
- | REDUCE
- | REFERENCES
+ | RECYCLE
| REFRESH
- | RENAME
- | REPAIR
| REPEATABLE
| REPLACE
- | RESET
- | RESPECT
- | RESTRICT
+ | REPLACE_IF_NOT_NULL
+ | REPOSITORIES
+ | REPOSITORY
+ | RESOURCE
+ | RESOURCES
+ | RESTORE
| RESTRICTIVE
- | REVOKE
+ | RESUME
+ | RETURNS
| REWRITTEN
| RLIKE
- | ROLE
- | ROLES
| ROLLBACK
| ROLLUP
- | ROWS
+ | ROUTINE
+ | S3
+ | SAMPLE
+ | SCHEDULER
| SCHEMA
- | SCHEMAS
| SECOND
- | SELECT
- | SEPARATED
- | SERDE
- | SERDEPROPERTIES
- | SESSION_USER
- | SET
- | SETS
- | SHOW
- | SKEWED
- | SOME
- | SORT
- | SORTED
+ | SERIALIZABLE
+ | SESSION
+ | SHAPE
+ | SKEW
+ | SNAPSHOT
+ | SONAME
+ | SPLIT
| START
- | STATISTICS
+ | STARTS
+ | STATS
+ | STATUS
+ | STOP
| STORAGE
- | STORED
- | STRATIFY
+ | STREAM
+ | STREAMING
+ | STRING
| STRUCT
- | SYNC
- | SYSTEM_TIME
- | SYSTEM_VERSION
- | TABLE
+ | SUBDATE
+ | SUM
| TABLES
- | TABLESAMPLE
- | TBLPROPERTIES
+ | TASK
+ | TASKS
| TEMPORARY
- | TERMINATED
- | THEN
+ | TEXT
+ | THAN
| TIME
| TIMESTAMP
| TIMESTAMPADD
| TIMESTAMPDIFF
- | TO
- | TOUCH
- | TRAILING
| TRANSACTION
- | TRANSACTIONS
- | TRANSFORM
- | TRIM
- | TRUE
+ | TRIGGERS
| TRUNCATE
- | TRY_CAST
| TYPE
- | UNARCHIVE
- | UNBOUNDED
- | UNCACHE
- | UNIQUE
- | UNKNOWN
+ | TYPES
+ | UNCOMMITTED
| UNLOCK
- | UNSET
- | UPDATE
- | USE
| USER
- | VALUES
+ | VALUE
+ | VARCHAR
+ | VARIABLES
| VERBOSE
| VERSION
| VIEW
- | VIEWS
+ | WARNINGS
| WEEK
- | WHEN
- | WHERE
- | WINDOW
- | WITH
- | WITHIN
+ | WORK
| YEAR
- | ZONE
- | S3
- | HDFS
- | BROKER
//--DEFAULT-NON-RESERVED-END
;
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java
index 088cfbc7c4..043ec32d44 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java
@@ -492,8 +492,8 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
@Override
public String visitIdentifierOrText(IdentifierOrTextContext ctx) {
- if (ctx.STRING() != null) {
- return ctx.STRING().getText().substring(1,
ctx.STRING().getText().length() - 1);
+ if (ctx.STRING_LITERAL() != null) {
+ return ctx.STRING_LITERAL().getText().substring(1,
ctx.STRING_LITERAL().getText().length() - 1);
} else {
return ctx.errorCapturingIdentifier().getText();
}
@@ -861,7 +861,7 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
switch (ctx.operator.getType()) {
case DorisParser.PLUS:
return e;
- case DorisParser.MINUS:
+ case DorisParser.SUBTRACT:
IntegerLiteral zero = new IntegerLiteral(0);
return new Subtract(zero, e);
case DorisParser.TILDE:
@@ -907,7 +907,7 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
Operator op;
if (type == DorisParser.PLUS) {
op = Operator.ADD;
- } else if (type == DorisParser.MINUS) {
+ } else if (type == DorisParser.SUBTRACT) {
op = Operator.SUBTRACT;
} else {
throw new ParseException("Only supported: " + Operator.ADD
+ " and " + Operator.SUBTRACT, ctx);
@@ -922,11 +922,11 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
return new Multiply(left, right);
case DorisParser.SLASH:
return new Divide(left, right);
- case DorisParser.PERCENT:
+ case DorisParser.MOD:
return new Mod(left, right);
case DorisParser.PLUS:
return new Add(left, right);
- case DorisParser.MINUS:
+ case DorisParser.SUBTRACT:
return new Subtract(left, right);
case DorisParser.DIV:
return new IntegralDivide(left, right);
@@ -1272,7 +1272,7 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
@Override
public Expression visitTypeConstructor(TypeConstructorContext ctx) {
- String value = ctx.STRING().getText();
+ String value = ctx.STRING_LITERAL().getText();
value = value.substring(1, value.length() - 1);
String type = ctx.type.getText().toUpperCase();
switch (type) {
@@ -1342,7 +1342,7 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
@Override
public Literal visitStringLiteral(StringLiteralContext ctx) {
// TODO: add unescapeSQLString.
- String txt = ctx.STRING().getText();
+ String txt = ctx.STRING_LITERAL().getText();
String s = escapeBackSlash(txt.substring(1, txt.length() - 1));
return new VarcharLiteral(s);
}
@@ -1998,7 +1998,7 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
@Override
public List<String> visitPrimitiveDataType(PrimitiveDataTypeContext ctx) {
- String dataType = ctx.identifier().getText().toLowerCase(Locale.ROOT);
+ String dataType =
ctx.primitiveColType().type.getText().toLowerCase(Locale.ROOT);
List<String> l = Lists.newArrayList(dataType);
ctx.INTEGER_VALUE().stream().map(ParseTree::getText).forEach(l::add);
return l;
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DataType.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DataType.java
index f608292f9b..a762193456 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DataType.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/types/DataType.java
@@ -180,7 +180,11 @@ public abstract class DataType implements AbstractDataType
{
case 1:
return VarcharType.SYSTEM_DEFAULT;
case 2:
- return
VarcharType.createVarcharType(Integer.parseInt(types.get(1)));
+ if (types.get(1).equals("*")) {
+ return VarcharType.SYSTEM_DEFAULT;
+ } else {
+ return
VarcharType.createVarcharType(Integer.parseInt(types.get(1)));
+ }
default:
throw new AnalysisException("Nereids do not support
type: " + type);
}
@@ -190,7 +194,11 @@ public abstract class DataType implements AbstractDataType
{
case 1:
return CharType.SYSTEM_DEFAULT;
case 2:
- return
CharType.createCharType(Integer.parseInt(types.get(1)));
+ if (types.get(1).equals("*")) {
+ return CharType.SYSTEM_DEFAULT;
+ } else {
+ return
CharType.createCharType(Integer.parseInt(types.get(1)));
+ }
default:
throw new AnalysisException("Nereids do not support
type: " + type);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org
