From 6310ad23d286cee5c4e60081c542fdf36116c793 Mon Sep 17 00:00:00 2001 From: Sergey Chernov Date: Wed, 11 Feb 2026 08:01:30 -0800 Subject: [PATCH] Added simpler parser --- .../parser/antlr4_light/ClickHouseLexer.g4 | 489 ++++++++++++++++++ .../antlr4_light/ClickHouseLightParser.g4 | 181 +++++++ .../jdbc/internal/SqlParserFacade.java | 29 ++ 3 files changed, 699 insertions(+) create mode 100644 jdbc-v2/src/main/antlr4/com/clickhouse/jdbc/internal/parser/antlr4_light/ClickHouseLexer.g4 create mode 100644 jdbc-v2/src/main/antlr4/com/clickhouse/jdbc/internal/parser/antlr4_light/ClickHouseLightParser.g4 diff --git a/jdbc-v2/src/main/antlr4/com/clickhouse/jdbc/internal/parser/antlr4_light/ClickHouseLexer.g4 b/jdbc-v2/src/main/antlr4/com/clickhouse/jdbc/internal/parser/antlr4_light/ClickHouseLexer.g4 new file mode 100644 index 000000000..64b99c264 --- /dev/null +++ b/jdbc-v2/src/main/antlr4/com/clickhouse/jdbc/internal/parser/antlr4_light/ClickHouseLexer.g4 @@ -0,0 +1,489 @@ + +// $antlr-format alignColons trailing, alignLabels true, alignLexerCommands true, alignSemicolons ownLine, alignTrailers true +// $antlr-format alignTrailingComments true, allowShortBlocksOnASingleLine true, allowShortRulesOnASingleLine true, columnLimit 150 +// $antlr-format maxEmptyLinesToKeep 1, minEmptyLines 0, reflowComments false, singleLineOverrulesHangingColon true, useTab false + +lexer grammar ClickHouseLexer; + +// NOTE: don't forget to add new keywords to the parser rule "keyword"! + +// Keywords + + + +ACCESS : A C C E S S; +ADD : A D D; +ADMIN : A D M I N; +AFTER : A F T E R; +ALIAS : A L I A S; +ALL : A L L; +ALLOW : A L L O W; +ALTER : A L T E R; +AND : A N D; +ANTI : A N T I; +ANY : A N Y; +ARBITRARY : A R B I T R A R Y ; +ARRAY : A R R A Y; +AS : A S; +ASCENDING : A S C | A S C E N D I N G; +ASOF : A S O F; +AST : A S T; +ASYNC : A S Y N C; +ASYNCHRONOUS : A S Y N C H R O N O U S ; +ATTACH : A T T A C H; +AZURE : A Z U R E; +BACKUP : B A C K U P; +BCRYPT_HASH : B C R Y P T '_' H A S H; +BCRYPT_PASSWORD : B C R Y P T '_' P A S S W O R D; +BETWEEN : B E T W E E N; +BLOCKING : B L O C K I N G ; +BOTH : B O T H; +BY : B Y; +CACHE : C A C H E ; +CACHES : C A C H E S ; +CANCEL : C A N C E L; +CASE : C A S E; +CAST : C A S T; +CHANGEABLE_IN_READONLY : C H A N G E A B L E UNDERSCORE I N UNDERSCORE R E A D O N L Y; +CHANGED : C H A N G E D; +CHECK : C H E C K; +CLEANUP : C L E A N U P; +CLEAR : C L E A R; +CLIENT : C L I E N T ; +CLUSTER : C L U S T E R; +CLUSTERS : C L U S T E R S; +CN : C N; +CODEC : C O D E C; +COLLATE : C O L L A T E; +COLLECTION : C O L L E C T I O N ; +COLLECTIONS : C O L L E C T I O N S ; +COLUMN : C O L U M N; +COLUMNS : C O L U M N S ; +COMMENT : C O M M E N T; +COMPILED : C O M P I L E D ; +CONDITION : C O N D I T I O N; +CONFIG : C O N F I G ; +CONNECTIONS : C O N N E C T I O N S ; +CONST : C O N S T; +CONSTRAINT : C O N S T R A I N T; +CREATE : C R E A T E; +CROSS : C R O S S; +CUBE : C U B E; +CURRENT : C U R R E N T; +CURRENT_USER : C U R R E N T '_' U S E R; +CUSTOM : C U S T O M; +DATABASE : D A T A B A S E; +DATABASES : D A T A B A S E S; +DATE : D A T E; +DAY : D A Y; +DEDUPLICATE : D E D U P L I C A T E; +DEFAULT : D E F A U L T; +DEFINER : D E F I N E R; +DELAY : D E L A Y; +DELETE : D E L E T E; +DESC : D E S C; +DESCENDING : D E S C E N D I N G; +DESCRIBE : D E S C R I B E; +DETACH : D E T A C H; +DICTIONARIES : D I C T I O N A R I E S; +DICTIONARY : D I C T I O N A R Y; +DISK : D I S K; +DISTINCT : D I S T I N C T; +DISTRIBUTED : D I S T R I B U T E D; +DNS : D N S ; +DOUBLE_SHA1_HASH : D O U B L E '_' S H A '1' '_' H A S H; +DOUBLE_SHA1_PASSWORD : D O U B L E '_' S H A '1' '_' P A S S W O R D; +DROP : D R O P; +ELSE : E L S E; +EMBEDDED : E M B E D D E D ; +ENABLED : E N A B L E D; +END : E N D; +ENGINE : E N G I N E; +ENGINES : E N G I N E S; +ESTIMATE : E S T I M A T E; +EVENTS : E V E N T S; +EXCEPT : E X C E P T; +EXCHANGE : E X C H A N G E; +EXISTS : E X I S T S; +EXPLAIN : E X P L A I N; +EXPRESSION : E X P R E S S I O N; +EXTENDED : E X T E N D E D; +EXTRACT : E X T R A C T; +FAILPOINT : F A I L P O I N T ; +FETCHES : F E T C H E S; +FETCH : F E T C H ; +FILE : F I L E; +FILESYSTEM : F I L E S Y S T E M ; +FILTER : F I L T E R; +FINAL : F I N A L; +FIRST : F I R S T; +FLUSH : F L U S H; +FOLLOWING : F O L L O W I N G; +FOR : F O R; +FORMAT : F O R M A T; +FREEZE : F R E E Z E; +FROM : F R O M; +FULL : F U L L; +FUNCTION : F U N C T I O N; +FUNCTIONS : F U N C T I O N S; +FUZZER : F U Z Z E R ; +GLOBAL : G L O B A L; +GRANTEES : G R A N T E E S; +GRANT : G R A N T; +GRANTS : G R A N T S; +GRANULARITY : G R A N U L A R I T Y; +GROUP : G R O U P; +GRPC : G R P C; +HAVING : H A V I N G; +HDFS : H D F S; +HIERARCHICAL : H I E R A R C H I C A L; +HIVE : H I V E; +HOST : H O S T; +HOUR : H O U R; +HTTP : H T T P; +HTTPS : H T T P S; +IDENTIFIED : I D E N T I F I E D; +ID : I D; +IF : I F; +ILIKE : I L I K E; +IMPLICIT : I M P L I C I T; +INDEXES : I N D E X E S; +INDEX : I N D E X; +INDICES : I N D I C E S; +INF : I N F | I N F I N I T Y; +INHERIT : I N H E R I T; +IN : I N; +INJECTIVE : I N J E C T I V E; +INNER : I N N E R; +INSERT : I N S E R T; +INTERVAL : I N T E R V A L; +INTO : I N T O; +INTROSPECTION : I N T R O S P E C T I O N; +IP : I P; +IS : I S; +IS_OBJECT_ID : I S UNDERSCORE O B J E C T UNDERSCORE I D; +JDBC : J D B C; +JEMALLOC : J E M A L L O C ; +JOIN : J O I N; +KAFKA : K A F K A; +KERBEROS : K E R B E R O S; +KEYED : K E Y E D; +KEY : K E Y; +KEYS : K E Y S; +KILL : K I L L; +LAST : L A S T; +LAYOUT : L A Y O U T; +LDAP : L D A P; +LEADING : L E A D I N G; +LEFT : L E F T; +LIFETIME : L I F E T I M E; +LIGHTWEIGHT : L I G H T W E I G H T; +LIKE : L I K E; +LIMIT : L I M I T; +LIMITS : L I M I T S; +LISTEN : L I S T E N ; +LIVE : L I V E; +LOADING : L O A D I N G; +LOAD : L O A D ; +LOCAL : L O C A L; +LOG : L O G ; +LOGS : L O G S; +MANAGEMENT : M A N A G E M E N T; +MARK : M A R K ; +MATERIALIZED : M A T E R I A L I Z E D; +MATERIALIZE : M A T E R I A L I Z E; +MAX : M A X; +MERGES : M E R G E S; +METRICS : M E T R I C S ; +MIN : M I N; +MINUTE : M I N U T E; +MMAP : M M A P ; +MODEL : M O D E L ; +MODIFY : M O D I F Y; +MONGO : M O N G O; +MONTH : M O N T H; +MOVE : M O V E; +MOVES : M O V E S ; +MUTATION : M U T A T I O N; +MYSQL : M Y S Q L; +NAMED : N A M E D ; +NAME : N A M E; +NAN_SQL : N A N; // conflicts with macro NAN +NATS : N A T S; +NONE : N O N E; +NO : N O; +NO_PASSWORD : N O '_' P A S S W O R D; +NOT : N O T; +NULLS : N U L L S; +NULL_SQL : N U L L; // conflicts with macro NULL +ODBC : O D B C; +OFFSET : O F F S E T; +ONLY : O N L Y; +ON : O N; +OPTIMIZE : O P T I M I Z E; +OPTION : O P T I O N; +ORDER : O R D E R; +OR : O R; +OUTER : O U T E R; +OUTFILE : O U T F I L E; +OVER : O V E R; +OVERRIDE : O V E R R I D E; +PAGE : P A G E ; +PARTITION : P A R T I T I O N; +PART : P A R T; +PARTS : P A R T S; +PERMISSIVE : P E R M I S S I V E; +PIPELINE : P I P E L I N E; +PLAINTEXT_PASSWORD : P L A I N T E X T '_' P A S S W O R D; +PLAN : P L A N; +POLICIES : P O L I C I E S ; +POLICY : P O L I C Y; +POPULATE : P O P U L A T E; +POSTGRES : P O S T G R E S; +POSTGRESQL : P O S T G R E S Q L; +PRECEDING : P R E C E D I N G; +PREWHERE : P R E W H E R E; +PRIMARY : P R I M A R Y; +PROCESSLIST : P R O C E S S L I S T; +PROFILE : P R O F I L E; +PROFILES : P R O F I L E S; +PROJECTION : P R O J E C T I O N; +PROMETHEUS : P R O M E T H E U S; +PROXY : P R O X Y; +PULLING : P U L L I N G ; +PULL : P U L L; +QUARTER : Q U A R T E R; +QUERIES : Q U E R I E S; +QUERY : Q U E R Y; +QUEUE : Q U E U E ; +QUEUES : Q U E U E S ; +QUOTA : Q U O T A; +QUOTAS : Q U O T A S ; +RABBITMQ : R A B B I T M Q; +RANDOMIZED : R A N D O M I Z E D; +RANGE : R A N G E; +READINESS : R E A D I N E S S; +READONLY : R E A D O N L Y; +REALM : R E A L M; +REDIS : R E D I S; +REDUCE : R E D U C E ; +REFRESH : R E F R E S H ; +REGEXP : R E G E X P; +RELOAD : R E L O A D; +REMOTE : R E M O T E; +REMOVE : R E M O V E; +RENAME : R E N A M E; +REPLACE : R E P L A C E; +REPLICA : R E P L I C A; +REPLICAS : R E P L I C A S; +REPLICATED : R E P L I C A T E D; +REPLICATION : R E P L I C A T I O N ; +RESOURCE : R E S O U R C E ; +RESTART : R E S T A R T; +RESTORE : R E S T O R E ; +RESTRICTIVE : R E S T R I C T I V E; +REVOKE : R E V O K E; +RIGHT : R I G H T; +ROLE : R O L E; +ROLES : R O L E S ; +ROLLUP : R O L L U P; +ROW : R O W; +ROWS : R O W S; +S3 : S '3'; +SAMPLE : S A M P L E; +SCHEMA : S C H E M A; +SCRAM_SHA256_HASH : S C R A M '_' S H A '2' '5' '6' '_' H A S H; +SCRAM_SHA256_PASSWORD : S C R A M '_' S H A '2' '5' '6' '_' P A S S W O R D; +SECOND : S E C O N D; +SECRETS : S E C R E T S ; +SECURE : S E C U R E; +SECURITY : S E C U R I T Y; +SELECT : S E L E C T; +SEMI : S E M I; +SENDS : S E N D S; +SERVER : S E R V E R; +SET : S E T; +SETTING : S E T T I N G; +SETTINGS : S E T T I N G S; +SHA256_HASH : S H A '2' '5' '6' '_' H A S H; +SHA256_PASSWORD : S H A '2' '5' '6' '_' P A S S W O R D; +SHARD : S H A R D; +SHARDS : S H A R D S; +SHOW : S H O W; +SHUTDOWN : S H U T D O W N ; +SOURCE : S O U R C E; +SOURCES : S O U R C E S; +SQLITE : S Q L I T E; +SQL : S Q L; +SSH_KEY : S S H '_' K E Y; +SSL_CERTIFICATE : S S L '_' C E R T I F I C A T E; +START : S T A R T; +STATISTICS : S T A T I S T I C S ; +STOP : S T O P; +STRICT : S T R I C T; +SUBSTRING : S U B S T R I N G; +SYNC : S Y N C; +SYNTAX : S Y N T A X; +SYSTEM : S Y S T E M; +TABLES : T A B L E S; +TABLE : T A B L E; +TAG : T A G; +TCP : T C P; +TEMPORARY : T E M P O R A R Y; +TEST : T E S T; +THEN : T H E N; +THREAD : T H R E A D ; +TIES : T I E S; +TIMEOUT : T I M E O U T; +TIMESTAMP : T I M E S T A M P; +TOP : T O P; +TOTALS : T O T A L S; +TO : T O; +TRACKING : T R A C K I N G; +TRAILING : T R A I L I N G; +TRANSACTION : T R A N S A C T I O N; +TREE : T R E E; +TRIM : T R I M; +TRUNCATE : T R U N C A T E; +TTL : T T L; +TYPE : T Y P E; +UNBOUNDED : U N B O U N D E D; +UNCOMPRESSED : U N C O M P R E S S E D ; +UNDROP : U N D R O P; +UNFREEZE : U N F R E E Z E ; +UNION : U N I O N; +UNLOAD : U N L O A D ; +UNTIL : U N T I L; +UPDATE : U P D A T E; +URL : U R L; +USERS : U S E R S ; +USER : U S E R; +USE : U S E; +USING : U S I N G; +UUID : U U I D; +VALID : V A L I D; +VALUES : V A L U E S; +VIEWS : V I E W S; +VIEW : V I E W; +VIRTUAL : V I R T U A L; +VOLUME : V O L U M E; +WAIT : W A I T; +WATCH : W A T C H; +WEEK : W E E K; +WHEN : W H E N; +WHERE : W H E R E; +WINDOW : W I N D O W; +WITH : W I T H; +WORKLOAD : W O R K L O A D; +WRITABLE : W R I T A B L E; +YEAR : Y E A R | Y Y Y Y; +ZKPATH : Z K P A T H; +SUM : S U M; +AVG : A V G; + +JSON_FALSE : 'false'; +JSON_TRUE : 'true'; + +// Tokens + +// Order matters: quoted identifiers must come before unquoted IDENTIFIER +BACKTICK_ID: + BACKQUOTE ( ~([\\`]) | (BACKSLASH .) | (BACKQUOTE BACKQUOTE))* BACKQUOTE +; + +QUOTED_IDENTIFIER: + QUOTE_DOUBLE (~([\\"]) | (BACKSLASH .) | (QUOTE_DOUBLE QUOTE_DOUBLE))* QUOTE_DOUBLE +; + +IDENTIFIER: + (LETTER | UNDERSCORE) (LETTER | UNDERSCORE | DEC_DIGIT)* + | DEC_DIGIT+ (LETTER | UNDERSCORE) (LETTER | UNDERSCORE | DEC_DIGIT)* +; +FLOATING_LITERAL: + HEXADECIMAL_LITERAL DOT HEX_DIGIT* (P | E) (PLUS | DASH)? DEC_DIGIT+ + | HEXADECIMAL_LITERAL (P | E) (PLUS | DASH)? DEC_DIGIT+ + | DECIMAL_LITERAL DOT DEC_DIGIT* E (PLUS | DASH)? DEC_DIGIT+ + | DOT DECIMAL_LITERAL E (PLUS | DASH)? DEC_DIGIT+ + | DECIMAL_LITERAL E (PLUS | DASH)? DEC_DIGIT+ +; +OCTAL_LITERAL : '0' OCT_DIGIT+; +DECIMAL_LITERAL : DEC_DIGIT+; +HEXADECIMAL_LITERAL : '0' X HEX_DIGIT+; + +CAST_OP : '::'; + +// It's important that quote-symbol is a single character. +STRING_LITERAL: + QUOTE_SINGLE (~([\\']) | (BACKSLASH .) | (QUOTE_SINGLE QUOTE_SINGLE))* QUOTE_SINGLE +; + +// Alphabet and allowed symbols + +fragment A : [aA]; +fragment B : [bB]; +fragment C : [cC]; +fragment D : [dD]; +fragment E : [eE]; +fragment F : [fF]; +fragment G : [gG]; +fragment H : [hH]; +fragment I : [iI]; +fragment J : [jJ]; +fragment K : [kK]; +fragment L : [lL]; +fragment M : [mM]; +fragment N : [nN]; +fragment O : [oO]; +fragment P : [pP]; +fragment Q : [qQ]; +fragment R : [rR]; +fragment S : [sS]; +fragment T : [tT]; +fragment U : [uU]; +fragment V : [vV]; +fragment W : [wW]; +fragment X : [xX]; +fragment Y : [yY]; +fragment Z : [zZ]; + +fragment LETTER : [a-zA-Z]; +fragment OCT_DIGIT : [0-7]; +fragment DEC_DIGIT : [0-9]; +fragment HEX_DIGIT : [0-9a-fA-F]; + +ARROW : '->'; +ASTERISK : '*'; +BACKQUOTE : '`'; +BACKSLASH : '\\'; +COLON : ':'; +COMMA : ','; +CONCAT : '||'; +DASH : '-'; +DOT : '.'; +EQ_DOUBLE : '=='; +EQ_SINGLE : '='; +GE : '>='; +GT : '>'; +LBRACE : '{'; +LBRACKET : '['; +LE : '<='; +LPAREN : '('; +LT : '<'; +NOT_EQ : '!=' | '<>'; +PERCENT : '%'; +PLUS : '+'; +JDBC_PARAM_PLACEHOLDER : '?'; +QUOTE_DOUBLE : '"'; +QUOTE_SINGLE : '\''; +RBRACE : '}'; +RBRACKET : ']'; +RPAREN : ')'; +SEMICOLON : ';'; +SLASH : '/'; +UNDERSCORE : '_'; + +// Comments and whitespace + +MULTI_LINE_COMMENT : '/*' .*? '*/' -> skip; +SINGLE_LINE_COMMENT : ('--' | '#!' | '#') ~('\n' | '\r')* ('\n' | '\r' | EOF) -> skip; +WHITESPACE : [ \u000B\u000C\t\r\n] -> skip; // '\n' can be part of multiline single query \ No newline at end of file diff --git a/jdbc-v2/src/main/antlr4/com/clickhouse/jdbc/internal/parser/antlr4_light/ClickHouseLightParser.g4 b/jdbc-v2/src/main/antlr4/com/clickhouse/jdbc/internal/parser/antlr4_light/ClickHouseLightParser.g4 new file mode 100644 index 000000000..fdfbb2dea --- /dev/null +++ b/jdbc-v2/src/main/antlr4/com/clickhouse/jdbc/internal/parser/antlr4_light/ClickHouseLightParser.g4 @@ -0,0 +1,181 @@ + +// Simplified ClickHouse SQL parser. +// +// Design goals: +// - Filter comments (handled by the lexer: /* */, --, #!, #) +// - Detect statement verb (SELECT, SHOW, INSERT, SET, EXPLAIN, etc.) +// - For INSERT: parse table name and optional column list +// - For SET: parse completely (key = value pairs) +// - For everything else: accept any tokens without detailed parsing + +parser grammar ClickHouseLightParser; + +options { + tokenVocab = ClickHouseLexer; +} + +// Top-level entry point + +queryStmt + : insertStmt SEMICOLON? EOF # InsertQueryStmt + | setStmt SEMICOLON? EOF # SetQueryStmt + | selectStmt SEMICOLON? EOF # SelectQueryStmt + | showStmt SEMICOLON? EOF # ShowQueryStmt + | explainStmt SEMICOLON? EOF # ExplainQueryStmt + | otherStmt SEMICOLON? EOF # OtherQueryStmt + ; + +// INSERT - parse table identifier and optional column list, accept rest + +insertStmt + : INSERT INTO FUNCTION identifier LPAREN functionArgs RPAREN columnsClause? restOfQuery # InsertFunctionStmt + | INSERT INTO TABLE? tableIdentifier columnsClause? restOfQuery # InsertTableStmt + ; + +columnsClause + : LPAREN nestedIdentifier (COMMA nestedIdentifier)* RPAREN + ; + +functionArgs + : (LPAREN functionArgs RPAREN | ~(LPAREN | RPAREN))* + ; + +// SET - fully parsed + +setStmt + : SET settingExprList + ; + +settingExprList + : settingExpr (COMMA settingExpr)* + ; + +settingExpr + : identifier EQ_SINGLE (literal | JDBC_PARAM_PLACEHOLDER) + ; + +// SELECT (including WITH ... SELECT for CTEs) - detect verb, accept rest + +selectStmt + : (WITH | SELECT) restOfQuery + ; + +// SHOW - detect verb, accept rest + +showStmt + : SHOW restOfQuery + ; + +// EXPLAIN - detect verb, accept rest + +explainStmt + : EXPLAIN restOfQuery + ; + +// Any other statement - accept all tokens + +otherStmt + : ~SEMICOLON+ + ; + +// Consume all remaining non-semicolon tokens + +restOfQuery + : ~SEMICOLON* + ; + +// Table and column identifiers + +tableIdentifier + : (identifier DOT)? identifier + ; + +nestedIdentifier + : identifier (DOT identifier)? + ; + +// Literals + +literal + : numberLiteral + | STRING_LITERAL + | NULL_SQL + | JSON_TRUE + | JSON_FALSE + ; + +numberLiteral + : (PLUS | DASH)? ( + FLOATING_LITERAL + | OCTAL_LITERAL + | DECIMAL_LITERAL + | HEXADECIMAL_LITERAL + | INF + | NAN_SQL + ) + ; + +// Identifiers - all keywords can be used as identifiers + +identifier + : BACKTICK_ID + | QUOTED_IDENTIFIER + | IDENTIFIER + | keyword + ; + +// All keywords (so they can appear as table names, column names, setting names, etc.) + +keyword + : ACCESS | ADD | ADMIN | AFTER | ALIAS | ALL | ALLOW | ALTER | AND | ANTI | ANY + | ARBITRARY | ARRAY | AS | ASCENDING | ASOF | AST | ASYNC | ASYNCHRONOUS | ATTACH + | AZURE + | BACKUP | BCRYPT_HASH | BCRYPT_PASSWORD | BETWEEN | BLOCKING | BOTH | BY + | CACHE | CACHES | CANCEL | CASE | CAST | CHANGEABLE_IN_READONLY | CHANGED | CHECK + | CLEANUP | CLEAR | CLIENT | CLUSTER | CLUSTERS | CN | CODEC | COLLATE | COLLECTION + | COLLECTIONS | COLUMN | COLUMNS | COMMENT | COMPILED | CONDITION | CONFIG | CONNECTIONS + | CONST | CONSTRAINT | CREATE | CROSS | CUBE | CURRENT | CURRENT_USER | CUSTOM + | DATABASE | DATABASES | DATE | DAY | DEDUPLICATE | DEFAULT | DEFINER | DELAY | DELETE + | DESC | DESCENDING | DESCRIBE | DETACH | DICTIONARIES | DICTIONARY | DISK | DISTINCT + | DISTRIBUTED | DNS | DOUBLE_SHA1_HASH | DOUBLE_SHA1_PASSWORD | DROP + | ELSE | EMBEDDED | ENABLED | END | ENGINE | ENGINES | ESTIMATE | EVENTS | EXCEPT + | EXCHANGE | EXISTS | EXPLAIN | EXPRESSION | EXTENDED | EXTRACT + | FAILPOINT | FETCH | FETCHES | FILE | FILESYSTEM | FILTER | FINAL | FIRST | FLUSH + | FOLLOWING | FOR | FORMAT | FREEZE | FROM | FULL | FUNCTION | FUNCTIONS | FUZZER + | GLOBAL | GRANT | GRANTEES | GRANTS | GRANULARITY | GROUP | GRPC + | HAVING | HDFS | HIERARCHICAL | HIVE | HOST | HOUR | HTTP | HTTPS + | ID | IDENTIFIED | IF | ILIKE | IMPLICIT | IN | INDEX | INDEXES | INDICES + | INHERIT | INJECTIVE | INNER | INSERT | INTERVAL | INTO | INTROSPECTION | IP | IS + | IS_OBJECT_ID + | JDBC | JEMALLOC | JOIN | JSON_FALSE | JSON_TRUE + | KAFKA | KERBEROS | KEY | KEYED | KEYS | KILL + | LAST | LAYOUT | LDAP | LEADING | LEFT | LIFETIME | LIGHTWEIGHT | LIKE | LIMIT | LIMITS + | LISTEN | LIVE | LOAD | LOADING | LOCAL | LOG | LOGS + | MANAGEMENT | MARK | MATERIALIZE | MATERIALIZED | MAX | MERGES | METRICS | MIN | MINUTE + | MMAP | MODEL | MODIFY | MONGO | MONTH | MOVE | MOVES | MUTATION | MYSQL + | NAME | NAMED | NATS | NO | NONE | NOT | NO_PASSWORD | NULLS | NULL_SQL + | ODBC | OFFSET | ON | ONLY | OPTIMIZE | OPTION | OR | ORDER | OUTER | OUTFILE | OVER + | OVERRIDE + | PAGE | PART | PARTITION | PARTS | PERMISSIVE | PIPELINE | PLAINTEXT_PASSWORD | PLAN + | POLICIES | POLICY | POPULATE | POSTGRES | POSTGRESQL | PRECEDING | PREWHERE | PRIMARY + | PROCESSLIST | PROFILE | PROFILES | PROJECTION | PROMETHEUS | PROXY | PULL | PULLING + | QUARTER | QUERIES | QUERY | QUEUE | QUEUES | QUOTA | QUOTAS + | RABBITMQ | RANDOMIZED | RANGE | READINESS | READONLY | REALM | REDIS | REDUCE | REFRESH + | REGEXP | RELOAD | REMOTE | REMOVE | RENAME | REPLACE | REPLICA | REPLICAS | REPLICATED + | REPLICATION | RESOURCE | RESTART | RESTORE | RESTRICTIVE | REVOKE | RIGHT | ROLE | ROLES + | ROLLUP | ROW | ROWS + | S3 | SAMPLE | SCHEMA | SCRAM_SHA256_HASH | SCRAM_SHA256_PASSWORD | SECOND | SECRETS + | SECURE | SECURITY | SELECT | SEMI | SENDS | SERVER | SET | SETTING | SETTINGS + | SHA256_HASH | SHA256_PASSWORD | SHARD | SHARDS | SHOW | SHUTDOWN | SOURCE | SOURCES + | SQLITE | SQL | SSH_KEY | SSL_CERTIFICATE | START | STATISTICS | STOP | STRICT + | SUBSTRING | SYNC | SYNTAX | SYSTEM + | TABLE | TABLES | TAG | TCP | TEMPORARY | TEST | THEN | THREAD | TIES | TIMEOUT + | TIMESTAMP | TO | TOP | TOTALS | TRACKING | TRAILING | TRANSACTION | TREE | TRIM + | TRUNCATE | TTL | TYPE + | UNBOUNDED | UNCOMPRESSED | UNDROP | UNFREEZE | UNION | UNLOAD | UNTIL | UPDATE | URL + | USE | USER | USERS | USING | UUID + | VALID | VALUES | VIEW | VIEWS | VIRTUAL | VOLUME + | WAIT | WATCH | WEEK | WHEN | WHERE | WINDOW | WITH | WORKLOAD | WRITABLE + | YEAR | ZKPATH + | SUM | AVG + ; diff --git a/jdbc-v2/src/main/java/com/clickhouse/jdbc/internal/SqlParserFacade.java b/jdbc-v2/src/main/java/com/clickhouse/jdbc/internal/SqlParserFacade.java index afb5dbf39..293d39083 100644 --- a/jdbc-v2/src/main/java/com/clickhouse/jdbc/internal/SqlParserFacade.java +++ b/jdbc-v2/src/main/java/com/clickhouse/jdbc/internal/SqlParserFacade.java @@ -3,6 +3,8 @@ import com.clickhouse.client.api.sql.SQLUtils; import com.clickhouse.data.ClickHouseUtils; import com.clickhouse.jdbc.internal.parser.antlr4.ClickHouseLexer; +import com.clickhouse.jdbc.internal.parser.antlr4.ClickHouseLightParser; +import com.clickhouse.jdbc.internal.parser.antlr4.ClickHouseLightParserListener; import com.clickhouse.jdbc.internal.parser.antlr4.ClickHouseParser; import com.clickhouse.jdbc.internal.parser.antlr4.ClickHouseParserBaseListener; import com.clickhouse.jdbc.internal.parser.javacc.ClickHouseSqlParser; @@ -402,6 +404,33 @@ public void enterViewParam(ClickHouseParser.ViewParamContext ctx) { } } + private static class ANTLR4LightParser extends SqlParserFacade { + + @Override + public ParsedStatement parsedStatement(String sql) { + return null; + } + + @Override + public ParsedPreparedStatement parsePreparedStatement(String sql) { + return null; + } + + + protected ClickHouseLightParser parseSQL(String sql, ClickHouseLightParserListener listener) { + CharStream charStream = CharStreams.fromString(sql); + ClickHouseLexer lexer = new ClickHouseLexer(charStream); + ClickHouseLightParser parser = new ClickHouseLightParser(new CommonTokenStream(lexer)); + parser.removeErrorListeners(); + parser.addErrorListener(new ANTLR4Parser.ParserErrorListener()); + + ClickHouseLightParser.QueryStmtContext parseTree = parser.queryStmt(); + IterativeParseTreeWalker.DEFAULT.walk(listener, parseTree); + + return parser; + } + } + private static void parseParameters(String originalQuery, ParsedPreparedStatement stmt) { int len = originalQuery.length(); for (int i = 0; i < len; i++) {