This is an automated email from the ASF dual-hosted git repository.
morrysnow pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new b93a1a83a5 [opt](Nereids) let keywords list same with legacy planner
(#23632)
b93a1a83a5 is described below
commit b93a1a83a51c6bd9b31947106ad140f43deee0fb
Author: morrySnow <[email protected]>
AuthorDate: Fri Sep 1 10:24:30 2023 +0800
[opt](Nereids) let keywords list same with legacy planner (#23632)
---
.../antlr4/org/apache/doris/nereids/DorisLexer.g4 | 355 +++++++++++------
.../antlr4/org/apache/doris/nereids/DorisParser.g4 | 432 +++++++++++----------
.../doris/nereids/parser/LogicalPlanBuilder.java | 76 ++--
.../trees/expressions/ExpressionEvaluator.java | 1 +
.../org/apache/doris/nereids/types/DataType.java | 15 +-
.../apache/doris/nereids/types/DataTypeTest.java | 15 +-
6 files changed, 528 insertions(+), 366 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 532f05dec2..ba81e1ba76 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
@@ -91,329 +91,445 @@ RIGHT_BRACE: '}';
// 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';
-CHAR: 'CHAR';
+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';
+COMPLETE: 'COMPLETE';
+CONFIG: 'CONFIG';
+CONNECTION: 'CONNECTION';
+CONNECTION_ID: 'CONNECTION_ID';
+CONSISTENT: 'CONSISTENT';
CONVERT: 'CONVERT';
-COST: 'COST';
+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_CEIL: 'DATE_CEIL';
DATE_DIFF: 'DATE_DIFF';
DATE_FLOOR: 'DATE_FLOOR';
DATE_SUB: 'DATE_SUB';
-DBPROPERTIES: 'DBPROPERTIES';
+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';
-ORDERED: 'ORDERED';
-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';
-TABLET: 'TABLET';
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
@@ -428,13 +544,14 @@ GT : '>';
GTE : '>=' | '!<';
PLUS: '+';
-MINUS: '-';
+SUBTRACT: '-';
ASTERISK: '*';
SLASH: '/';
-PERCENT: '%';
+MOD: '%';
TILDE: '~';
AMPERSAND: '&';
LOGICALAND: '&&';
+LOGICALNOT: '!';
PIPE: '|';
DOUBLEPIPES: '||';
HAT: '^';
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 2441aad9e4..a75e293dd5 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
@@ -334,7 +334,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,6 +344,8 @@ booleanExpression
| left=booleanExpression operator=DOUBLEPIPES right=booleanExpression
#doublePipes
;
+
+
predicate
: NOT? kind=BETWEEN lower=valueExpression AND upper=valueExpression
| NOT? kind=(LIKE | REGEXP | RLIKE) pattern=valueExpression
@@ -355,9 +357,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
@@ -448,7 +450,20 @@ functionIdentifier
functionNameIdentifier
: identifier
- | LEFT | RIGHT
+ | ADD
+ | CONNECTION_ID
+ | CURRENT_CATALOG
+ | CURRENT_USER
+ | DATABASE
+ | IF
+ | LEFT
+ | LIKE
+ | PASSWORD
+ | REGEXP
+ | RIGHT
+ | SCHEMA
+ | TRIM
+ | USER
;
windowSpec
@@ -520,11 +535,40 @@ unitIdentifier
;
dataType
- : complex=ARRAY LT dataType GT
#complexDataType
- | complex=MAP LT dataType COMMA dataType GT
#complexDataType
- | complex=STRUCT LT complexColTypeList GT
#complexDataType
- | identifier (LEFT_PAREN INTEGER_VALUE
- (COMMA INTEGER_VALUE)* RIGHT_PAREN)?
#primitiveDataType
+ : complex=ARRAY LT dataType GT
#complexDataType
+ | complex=MAP LT dataType COMMA dataType GT
#complexDataType
+ | complex=STRUCT LT complexColTypeList GT
#complexDataType
+ | 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
;
complexColTypeList
@@ -548,7 +592,7 @@ errorCapturingIdentifier
// extra left-factoring grammar
errorCapturingIdentifierExtra
- : (MINUS identifier)+ #errorIdent
+ : (SUBTRACT identifier)+ #errorIdent
| #realIdent
;
@@ -567,8 +611,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.
@@ -578,285 +622,269 @@ 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
+ | COMPLETE
+ | CONFIG
+ | CONNECTION
+ | CONNECTION_ID
+ | CONSISTENT
| CONVERT
- | COST
- | CREATE
- | CUBE
- | CURRENT
- | CURRENT_DATE
- | CURRENT_TIME
+ | COPY
+ | COUNT
+ | CREATION
+ | CRON
+ | CURRENT_CATALOG
| CURRENT_TIMESTAMP
- | CURRENT_USER
| DATA
- | DATABASE
- | DATABASES
| DATE
- | DATEV2
| DATE_ADD
| DATE_CEIL
- | DATEDIFF
| 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
+ | LDAP
+ | LDAP_ADMIN_PASSWORD
| LEFT_BRACE
- | LIKE
- | ILIKE
- | LIMIT
+ | 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
- | ORDERED
- | 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
| RIGHT_BRACE
| 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
;
\ No newline at end of file
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 56471ac39a..991df341e4 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
@@ -929,7 +929,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:
@@ -975,7 +975,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);
@@ -990,11 +990,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);
@@ -1236,19 +1236,11 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
@Override
public Expression visitCast(DorisParser.CastContext ctx) {
- DataType dataType = ((DataType)
typedVisit(ctx.dataType())).conversion();
- Expression cast = ParserUtils.withOrigin(ctx, () ->
- new Cast(getExpression(ctx.expression()), dataType));
- if (dataType.isStringLikeType() && ((CharacterType) dataType).getLen()
>= 0) {
- List<Expression> args = ImmutableList.of(
- cast,
- new TinyIntLiteral((byte) 1),
- Literal.of(((CharacterType) dataType).getLen())
- );
- return new UnboundFunction("substr", args);
- } else {
- return cast;
- }
+ return ParserUtils.withOrigin(ctx, () -> {
+ DataType dataType = ((DataType)
typedVisit(ctx.dataType())).conversion();
+ Expression cast = new Cast(getExpression(ctx.expression()),
dataType);
+ return processCast(cast, dataType);
+ });
}
@Override
@@ -1262,31 +1254,41 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
@Override
public Expression visitEncryptKey(DorisParser.EncryptKeyContext ctx) {
- String db = ctx.dbName == null ? "" : ctx.dbName.getText();
- String key = ctx.keyName.getText();
- return new EncryptKeyRef(new StringLiteral(db), new
StringLiteral(key));
+ return ParserUtils.withOrigin(ctx, () -> {
+ String db = ctx.dbName == null ? "" : ctx.dbName.getText();
+ String key = ctx.keyName.getText();
+ return new EncryptKeyRef(new StringLiteral(db), new
StringLiteral(key));
+ });
}
@Override
public Expression visitCharFunction(DorisParser.CharFunctionContext ctx) {
- String charSet = ctx.charSet == null ? "utf8" : ctx.charSet.getText();
- List<Expression> arguments = ImmutableList.<Expression>builder()
- .add(new StringLiteral(charSet))
- .addAll(visit(ctx.arguments, Expression.class))
- .build();
- return new Char(arguments);
+ return ParserUtils.withOrigin(ctx, () -> {
+ String charSet = ctx.charSet == null ? "utf8" :
ctx.charSet.getText();
+ List<Expression> arguments = ImmutableList.<Expression>builder()
+ .add(new StringLiteral(charSet))
+ .addAll(visit(ctx.arguments, Expression.class))
+ .build();
+ return new Char(arguments);
+ });
}
@Override
public Expression visitConvertCharSet(DorisParser.ConvertCharSetContext
ctx) {
- return new ConvertTo(getExpression(ctx.argument), new
StringLiteral(ctx.charSet.getText()));
+ return ParserUtils.withOrigin(ctx,
+ () -> new ConvertTo(getExpression(ctx.argument), new
StringLiteral(ctx.charSet.getText())));
}
@Override
public Expression visitConvertType(DorisParser.ConvertTypeContext ctx) {
- DataType dataType = ((DataType) typedVisit(ctx.type)).conversion();
- Expression cast = ParserUtils.withOrigin(ctx, () ->
- new Cast(getExpression(ctx.argument), dataType));
+ return ParserUtils.withOrigin(ctx, () -> {
+ DataType dataType = ((DataType) typedVisit(ctx.type)).conversion();
+ Expression cast = new Cast(getExpression(ctx.argument), dataType);
+ return processCast(cast, dataType);
+ });
+ }
+
+ private Expression processCast(Expression cast, DataType dataType) {
if (dataType.isStringLikeType() && ((CharacterType) dataType).getLen()
>= 0) {
List<Expression> args = ImmutableList.of(
cast,
@@ -1305,14 +1307,13 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
String functionName =
ctx.functionIdentifier().functionNameIdentifier().getText();
boolean isDistinct = ctx.DISTINCT() != null;
List<Expression> params = visit(ctx.expression(),
Expression.class);
-
List<OrderKey> orderKeys = visit(ctx.sortItem(), OrderKey.class);
if (!orderKeys.isEmpty()) {
return parseFunctionWithOrderKeys(functionName, isDistinct,
params, orderKeys, ctx);
}
List<UnboundStar> unboundStars =
ExpressionUtils.collectAll(params, UnboundStar.class::isInstance);
- if (unboundStars.size() > 0) {
+ if (!unboundStars.isEmpty()) {
if (functionName.equalsIgnoreCase("count")) {
if (unboundStars.size() > 1) {
throw new ParseException(
@@ -2210,7 +2211,7 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
@Override
public DataType visitPrimitiveDataType(PrimitiveDataTypeContext ctx) {
return ParserUtils.withOrigin(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 DataType.convertPrimitiveFromStrings(l);
@@ -2240,8 +2241,13 @@ public class LogicalPlanBuilder extends
DorisParserBaseVisitor<Object> {
@Override
public StructField visitComplexColType(ComplexColTypeContext ctx) {
- String comment = ctx.commentSpec().STRING_LITERAL().getText();
- comment = escapeBackSlash(comment.substring(1, comment.length() - 1));
+ String comment;
+ if (ctx.commentSpec() != null) {
+ comment = ctx.commentSpec().STRING_LITERAL().getText();
+ comment = escapeBackSlash(comment.substring(1, comment.length() -
1));
+ } else {
+ comment = "";
+ }
return new StructField(ctx.identifier().getText(),
typedVisit(ctx.dataType()), true, comment);
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/ExpressionEvaluator.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/ExpressionEvaluator.java
index a3b5fda56c..f17489d8a6 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/ExpressionEvaluator.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/ExpressionEvaluator.java
@@ -50,6 +50,7 @@ import java.util.List;
* An expression evaluator that evaluates the value of an expression.
*/
public enum ExpressionEvaluator {
+
INSTANCE;
private ImmutableMultimap<String, FunctionInvoker> functions;
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 5f233c959b..0e894f7d1a 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
@@ -112,14 +112,12 @@ public abstract class DataType {
public static DataType convertPrimitiveFromStrings(List<String> types) {
String type = types.get(0).toLowerCase().trim();
switch (type) {
- case "bool":
case "boolean":
return BooleanType.INSTANCE;
case "tinyint":
return TinyIntType.INSTANCE;
case "smallint":
return SmallIntType.INSTANCE;
- case "integer":
case "int":
return IntegerType.INSTANCE;
case "bigint":
@@ -163,7 +161,11 @@ public abstract class DataType {
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);
}
@@ -173,7 +175,11 @@ public abstract class DataType {
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);
}
@@ -211,6 +217,7 @@ public abstract class DataType {
case "quantile_state":
return QuantileStateType.INSTANCE;
case "json":
+ case "jsonb":
return JsonType.INSTANCE;
default:
throw new AnalysisException("Nereids do not support type: " +
type);
diff --git
a/fe/fe-core/src/test/java/org/apache/doris/nereids/types/DataTypeTest.java
b/fe/fe-core/src/test/java/org/apache/doris/nereids/types/DataTypeTest.java
index 9633db6249..608130d6a2 100644
--- a/fe/fe-core/src/test/java/org/apache/doris/nereids/types/DataTypeTest.java
+++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/types/DataTypeTest.java
@@ -23,6 +23,7 @@ import org.apache.doris.nereids.types.coercion.FractionalType;
import org.apache.doris.nereids.types.coercion.IntegralType;
import org.apache.doris.nereids.types.coercion.NumericType;
+import com.google.common.collect.ImmutableList;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
@@ -67,7 +68,6 @@ public class DataTypeTest {
@Test
void testConvertFromString() {
// boolean
- Assertions.assertEquals(BooleanType.INSTANCE,
DataType.convertFromString("bool"));
Assertions.assertEquals(BooleanType.INSTANCE,
DataType.convertFromString("boolean"));
// tinyint
Assertions.assertEquals(TinyIntType.INSTANCE,
DataType.convertFromString("tinyint"));
@@ -95,13 +95,11 @@ public class DataTypeTest {
Assertions.assertEquals(StringType.INSTANCE,
DataType.convertFromString("string"));
// char
Assertions.assertEquals(CharType.createCharType(10),
DataType.convertFromString("char(10)"));
- Assertions.assertEquals(CharType.createCharType(10),
DataType.convertFromString("character(10)"));
-
+ Assertions.assertEquals(CharType.SYSTEM_DEFAULT,
DataType.convertFromString("character"));
// varchar
Assertions.assertEquals(VarcharType.createVarcharType(10),
DataType.convertFromString("varchar(10)"));
- // null
- Assertions.assertEquals(NullType.INSTANCE,
DataType.convertFromString("null"));
- Assertions.assertEquals(NullType.INSTANCE,
DataType.convertFromString("null_type"));
+ Assertions.assertEquals(VarcharType.SYSTEM_DEFAULT,
DataType.convertFromString("varchar(*)"));
+ Assertions.assertEquals(VarcharType.SYSTEM_DEFAULT,
DataType.convertFromString("varchar"));
// date
Assertions.assertEquals(DateType.INSTANCE,
DataType.convertFromString("date"));
// datev2
@@ -124,6 +122,11 @@ public class DataTypeTest {
Assertions.assertEquals(JsonType.INSTANCE,
DataType.convertFromString("json"));
// array
Assertions.assertEquals(ArrayType.of(IntegerType.INSTANCE),
DataType.convertFromString("array<int>"));
+ // map
+ Assertions.assertEquals(MapType.of(IntegerType.INSTANCE,
IntegerType.INSTANCE), DataType.convertFromString("map<int, int>"));
+ // struct
+ Assertions.assertEquals(new StructType(ImmutableList.of(new
StructField("a", IntegerType.INSTANCE, true, ""))),
DataType.convertFromString("struct<a: int>"));
+
}
@Test
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
