You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by pa...@apache.org on 2020/06/17 02:56:26 UTC
[shardingsphere] branch master updated: Refactor pg grammar file,
fix #5802 (#6045)
This is an automated email from the ASF dual-hosted git repository.
panjuan pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 7f57b22 Refactor pg grammar file, fix #5802 (#6045)
7f57b22 is described below
commit 7f57b22b200a4ee3fbd72ec241dab2063b893d90
Author: JingShang Lu <ji...@gmail.com>
AuthorDate: Wed Jun 17 10:56:15 2020 +0800
Refactor pg grammar file, fix #5802 (#6045)
* Refactor pg grammar file, fix #5802
* Simplify code
* format code
* format code
---
.../src/main/antlr4/imports/postgresql/BaseRule.g4 | 1326 +++++++++++++++++---
.../main/antlr4/imports/postgresql/DDLStatement.g4 | 12 +-
.../main/antlr4/imports/postgresql/DMLStatement.g4 | 482 +++++--
.../src/main/antlr4/imports/postgresql/Keyword.g4 | 128 +-
.../src/main/antlr4/imports/postgresql/Literals.g4 | 2 +-
.../antlr4/imports/postgresql/PostgreSQLKeyword.g4 | 758 +++++++++++
.../src/main/antlr4/imports/postgresql/Symbol.g4 | 2 +
.../postgresql/visitor/PostgreSQLVisitor.java | 460 +++----
.../visitor/impl/PostgreSQLDMLVisitor.java | 713 ++++++-----
.../src/test/resources/case/dml/select.xml | 19 +-
10 files changed, 3021 insertions(+), 881 deletions(-)
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/BaseRule.g4 b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/BaseRule.g4
index f77e4d5..1284173 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/BaseRule.g4
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/BaseRule.g4
@@ -23,41 +23,92 @@ parameterMarker
: QUESTION_ literalsType_?
;
-literals
- : stringLiterals
- | numberLiterals
- | hexadecimalLiterals
- | bitValueLiterals
- | booleanLiterals
- | nullValueLiterals
- ;
-
-stringLiterals
- : unicodeEscapes_? STRING_ literalsType_? uescape_?
- ;
+reserved_keyword
+ : ALL
+ | ANALYSE
+ | ANALYZE
+ | AND
+ | ANY
+ | ARRAY
+ | AS
+ | ASC
+ | ASYMMETRIC
+ | BOTH
+ | CASE
+ | CAST
+ | CHECK
+ | COLLATE
+ | COLUMN
+ | CONSTRAINT
+ | CREATE
+ | CURRENT_CATALOG
+ | CURRENT_DATE
+ | CURRENT_ROLE
+ | CURRENT_TIME
+ | CURRENT_TIMESTAMP
+ | CURRENT_USER
+ | DEFAULT
+ | DEFERRABLE
+ | DESC
+ | DISTINCT
+ | DO
+ | ELSE
+ | END
+ | EXCEPT
+ | FALSE
+ | FETCH
+ | FOR
+ | FOREIGN
+ | FROM
+ | GRANT
+ | GROUP
+ | HAVING
+ | IN
+ | INITIALLY
+ | INTERSECT
+ | INTO
+ | LATERAL
+ | LEADING
+ | LIMIT
+ | LOCALTIME
+ | LOCALTIMESTAMP
+ | NOT
+ | NULL
+ | OFFSET
+ | ON
+ | ONLY
+ | OR
+ | ORDER
+ | PLACING
+ | PRIMARY
+ | REFERENCES
+ | RETURNING
+ | SELECT
+ | SESSION_USER
+ | SOME
+ | SYMMETRIC
+ | TABLE
+ | THEN
+ | TO
+ | TRAILING
+ | TRUE
+ | UNION
+ | UNIQUE
+ | USER
+ | USING
+ | VARIADIC
+ | WHEN
+ | WHERE
+ | WINDOW
+ | WITH
+ ;
numberLiterals
: MINUS_? NUMBER_ literalsType_?
;
-hexadecimalLiterals
- : HEX_DIGIT_
- ;
-
-bitValueLiterals
- : BIT_NUM_
- ;
-
-booleanLiterals
- : TRUE | FALSE
- ;
-
-nullValueLiterals
- : NULL
- ;
-
literalsType_
- : COLON_ COLON_ IDENTIFIER_
+ : TYPE_CAST_ IDENTIFIER_
;
identifier
@@ -73,29 +124,332 @@ uescape_
;
unreservedWord
- : ADMIN | ESCAPE | EXCLUDE | KEY | PARTITION | SET | UNKNOWN
- | ADD | ALTER | ALWAYS | CASCADE | COMMIT | CURRENT | DAY
- | DELETE | DISABLE | DROP | ENABLE | FUNCTION | GENERATED | INDEX
- | ISOLATION | LEVEL | OPTION | PRIVILEGES | READ | REVOKE | ROLE
- | ROLLBACK | ROWS | START | TRANSACTION | TRUNCATE | YEAR | ACTION
- | BEGIN | CACHE | CHARACTERISTICS | CLUSTER | COMMENTS | CONSTRAINTS | CYCLE
- | DATA | DATABASE | DEFAULTS | DEFERRED | DEPENDS | DOMAIN | EXCLUDING
- | EXECUTE | EXTENDED | EXTENSION | EXTERNAL | EXTRACT | FILTER
- | FIRST | FOLLOWING | FORCE | GLOBAL | HOUR | IDENTITY | IF | IMMEDIATE
- | INCLUDING | INCREMENT | INDEXES | INHERIT | INHERITS | INCLUDE | INSERT
- | LANGUAGE | LARGE | LAST | LOCAL | LOGGED | MAIN | MATCH
- | MAXVALUE | MINVALUE | MINUTE | MONTH | NOTHING | NULLS | OBJECT
- | OF | OIDS | OVER | OWNED | OWNER | PARTIAL | PLAIN
- | PRECEDING | PROCEDURE | RANGE | RENAME | REPLICA | RESET | RESTART
- | RESTRICT | ROUTINE | RULE | SAVEPOINT | SCHEMA | SECOND | SECURITY
- | SEQUENCE | SESSION | SHOW | SIMPLE | STATISTICS | STORAGE | TABLESPACE
- | TEMP | TEMPORARY | TRIGGER | TYPE | UNBOUNDED | UNLOGGED | UPDATE
- | USAGE | VALID | VALIDATE | WITHIN | WITHOUT | ZONE | GROUPS
- | RECURSIVE | INSTANCE | DEFINER | PRESERVE | SQL | LOCAL | CASCADED
- | CLOSE | OPEN | NEXT | NAME | NAMES | INTEGER | REAL | DECIMAL | TYPE
- | BOOLEAN | CHAR | TIME | TIMESTAMP | INTERVAL
- | INT2 | INT4 | INT8 | FLOAT4 | FLOAT8 | MACADDR8 | INT4RANGE | INT8RANGE
- ;
+ : ABORT
+ | ABSOLUTE
+ | ACCESS
+ | ACTION
+ | ADD
+ | ADMIN
+ | AFTER
+ | AGGREGATE
+ | ALSO
+ | ALTER
+ | ALWAYS
+ | ASSERTION
+ | ASSIGNMENT
+ | AT
+ | ATTACH
+ | ATTRIBUTE
+ | BACKWARD
+ | BEFORE
+ | BEGIN
+ | BY
+ | CACHE
+ | CALL
+ | CALLED
+ | CASCADE
+ | CASCADED
+ | CATALOG
+ | CHAIN
+ | CHARACTERISTICS
+ | CHECKPOINT
+ | CLASS
+ | CLOSE
+ | CLUSTER
+ | COLUMNS
+ | COMMENT
+ | COMMENTS
+ | COMMIT
+ | COMMITTED
+ | CONFIGURATION
+ | CONFLICT
+ | CONNECTION
+ | CONSTRAINTS
+ | CONTENT
+ | CONTINUE
+ | CONVERSION
+ | COPY
+ | COST
+ | CSV
+ | CUBE
+ | CURRENT
+ | CURSOR
+ | CYCLE
+ | DATA
+ | DATABASE
+ | DAY
+ | DEALLOCATE
+ | DECLARE
+ | DEFAULTS
+ | DEFERRED
+ | DEFINER
+ | DELETE
+ | DELIMITER
+ | DELIMITERS
+ | DEPENDS
+ | DETACH
+ | DICTIONARY
+ | DISABLE
+ | DISCARD
+ | DOCUMENT
+ | DOMAIN
+ | DOUBLE
+ | DROP
+ | EACH
+ | ENABLE
+ | ENCODING
+ | ENCRYPTED
+ | ENUM
+ | ESCAPE
+ | EVENT
+ | EXCLUDE
+ | EXCLUDING
+ | EXCLUSIVE
+ | EXECUTE
+ | EXPLAIN
+ | EXPRESSION
+ | EXTENSION
+ | EXTERNAL
+ | FAMILY
+ | FILTER
+ | FIRST
+ | FOLLOWING
+ | FORCE
+ | FORWARD
+ | FUNCTION
+ | FUNCTIONS
+ | GENERATED
+ | GLOBAL
+ | GRANTED
+ | GROUPS
+ | HANDLER
+ | HEADER
+ | HOLD
+ | HOUR
+ | IDENTITY
+ | IF
+ | IMMEDIATE
+ | IMMUTABLE
+ | IMPLICIT
+ | IMPORT
+ | INCLUDE
+ | INCLUDING
+ | INCREMENT
+ | INDEX
+ | INDEXES
+ | INHERIT
+ | INHERITS
+ | INLINE
+ | INPUT
+ | INSENSITIVE
+ | INSERT
+ | INSTEAD
+ | INVOKER
+ | ISOLATION
+ | KEY
+ | LABEL
+ | LANGUAGE
+ | LARGE
+ | LAST
+ | LEAKPROOF
+ | LEVEL
+ | LISTEN
+ | LOAD
+ | LOCAL
+ | LOCATION
+ | LOCK
+ | LOCKED
+ | LOGGED
+ | MAPPING
+ | MATCH
+ | MATERIALIZED
+ | MAXVALUE
+ | METHOD
+ | MINUTE
+ | MINVALUE
+ | MODE
+ | MONTH
+ | MOVE
+ | NAME
+ | NAMES
+ | NEW
+ | NEXT
+ | NFC
+ | NFD
+ | NFKC
+ | NFKD
+ | NO
+ | NORMALIZED
+ | NOTHING
+ | NOTIFY
+ | NOWAIT
+ | NULLS
+ | OBJECT
+ | OF
+ | OFF
+ | OIDS
+ | OLD
+ | OPERATOR
+ | OPTION
+ | OPTIONS
+ | ORDINALITY
+ | OTHERS
+ | OVER
+ | OVERRIDING
+ | OWNED
+ | OWNER
+ | PARALLEL
+ | PARSER
+ | PARTIAL
+ | PARTITION
+ | PASSING
+ | PASSWORD
+ | PLANS
+ | POLICY
+ | PRECEDING
+ | PREPARE
+ | PREPARED
+ | PRESERVE
+ | PRIOR
+ | PRIVILEGES
+ | PROCEDURAL
+ | PROCEDURE
+ | PROCEDURES
+ | PROGRAM
+ | PUBLICATION
+ | QUOTE
+ | RANGE
+ | READ
+ | REASSIGN
+ | RECHECK
+ | RECURSIVE
+ | REF
+ | REFERENCING
+ | REFRESH
+ | REINDEX
+ | RELATIVE
+ | RELEASE
+ | RENAME
+ | REPEATABLE
+ | REPLACE
+ | REPLICA
+ | RESET
+ | RESTART
+ | RESTRICT
+ | RETURNS
+ | REVOKE
+ | ROLE
+ | ROLLBACK
+ | ROLLUP
+ | ROUTINE
+ | ROUTINES
+ | ROWS
+ | RULE
+ | SAVEPOINT
+ | SCHEMA
+ | SCHEMAS
+ | SCROLL
+ | SEARCH
+ | SECOND
+ | SECURITY
+ | SEQUENCE
+ | SEQUENCES
+ | SERIALIZABLE
+ | SERVER
+ | SESSION
+ | SET
+ | SETS
+ | SHARE
+ | SHOW
+ | SIMPLE
+// | SKIP
+ | SNAPSHOT
+ | SQL
+ | STABLE
+ | STANDALONE
+ | START
+ | STATEMENT
+ | STATISTICS
+ | STDIN
+ | STDOUT
+ | STORAGE
+ | STORED
+ | STRICT
+ | STRIP
+ | SUBSCRIPTION
+ | SUPPORT
+ | SYSID
+ | SYSTEM
+ | TABLES
+ | TABLESPACE
+ | TEMP
+ | TEMPLATE
+ | TEMPORARY
+ | TEXT
+ | TIES
+ | TRANSACTION
+ | TRANSFORM
+ | TRIGGER
+ | TRUNCATE
+ | TRUSTED
+ | TYPE
+ | TYPES
+ | UESCAPE
+ | UNBOUNDED
+ | UNCOMMITTED
+ | UNENCRYPTED
+ | UNKNOWN
+ | UNLISTEN
+ | UNLOGGED
+ | UNTIL
+ | UPDATE
+ | VACUUM
+ | VALID
+ | VALIDATE
+ | VALIDATOR
+ | VALUE
+ | VARYING
+ | VERSION
+ | VIEW
+ | VIEWS
+ | VOLATILE
+ | WHITESPACE
+ | WITHIN
+ | WITHOUT
+ | WORK
+ | WRAPPER
+ | WRITE
+ | XML
+ | YEAR
+ | YES
+ | ZONE
+ ;
+
+typeFuncNameKeyword
+ : AUTHORIZATION
+ | BINARY
+ | COLLATION
+ | CONCURRENTLY
+ | CROSS
+ | CURRENT_SCHEMA
+ | FREEZE
+ | FULL
+ | ILIKE
+ | INNER
+ | IS
+ | ISNULL
+ | JOIN
+ | LEFT
+ | LIKE
+ | NATURAL
+ | NOTNULL
+ | OUTER
+ | OVERLAPS
+ | RIGHT
+ | SIMILAR
+ | TABLESAMPLE
+ | VERBOSE
+ ;
schemaName
: identifier
@@ -141,162 +495,830 @@ primaryKey
: PRIMARY? KEY
;
-// TODO comb expr
-expr
- : expr logicalOperator expr
- | notOperator_ expr
- | LP_ expr RP_
- | booleanPrimary
- ;
-
logicalOperator
: OR | OR_ | AND | AND_
;
-notOperator_
- : NOT | NOT_
+comparisonOperator
+ : EQ_ | GTE_ | GT_ | LTE_ | LT_ | NEQ_
;
-booleanPrimary
- : booleanPrimary IS NOT? (TRUE | FALSE | UNKNOWN | NULL)
- | booleanPrimary SAFE_EQ_ predicate
- | booleanPrimary comparisonOperator predicate
- | booleanPrimary comparisonOperator (ALL | ANY) subquery
- | predicate
+
+cursorName
+ : name
+ ;
+
+aExpr
+ : cExpr
+ | aExpr TYPE_CAST_ typeName
+ | aExpr COLLATE anyName
+ | aExpr AT TIME ZONE aExpr
+ | PLUS_ aExpr
+ | MINUS_ aExpr
+ | aExpr PLUS_ aExpr
+ | aExpr MINUS_ aExpr
+ | aExpr ASTERISK_ aExpr
+ | aExpr SLASH_ aExpr
+ | aExpr MOD_ aExpr
+ | aExpr CARET_ aExpr
+ | aExpr comparisonOperator aExpr
+ | LP_ aExpr RP_ optIndirection
+ | aExpr qualOp aExpr
+ | qualOp aExpr
+ | aExpr qualOp
+ | NOT aExpr
+ | aExpr LIKE aExpr
+ | aExpr LIKE aExpr ESCAPE aExpr
+ | aExpr NOT LIKE aExpr
+ | aExpr NOT LIKE aExpr ESCAPE aExpr
+ | aExpr ILIKE aExpr
+ | aExpr ILIKE aExpr ESCAPE aExpr
+ | aExpr NOT ILIKE aExpr
+ | aExpr NOT ILIKE aExpr ESCAPE aExpr
+ | aExpr SIMILAR TO aExpr
+ | aExpr SIMILAR TO aExpr ESCAPE aExpr
+ | aExpr NOT SIMILAR TO aExpr
+ | aExpr NOT SIMILAR TO aExpr ESCAPE aExpr
+ | aExpr IS NULL
+ | aExpr ISNULL
+ | aExpr IS NOT NULL
+ | aExpr NOTNULL
+ | row OVERLAPS row
+ | aExpr IS TRUE
+ | aExpr IS NOT TRUE
+ | aExpr IS FALSE
+ | aExpr IS NOT FALSE
+ | aExpr IS UNKNOWN
+ | aExpr IS NOT UNKNOWN
+ | aExpr IS DISTINCT FROM aExpr
+ | aExpr IS NOT DISTINCT FROM aExpr
+ | aExpr IS OF LP_ typeList RP_
+ | aExpr IS NOT OF LP_ typeList RP_
+ | aExpr BETWEEN ASYMMETRIC? bExpr AND aExpr
+ | aExpr NOT BETWEEN ASYMMETRIC? bExpr AND aExpr
+ | aExpr BETWEEN SYMMETRIC bExpr AND aExpr
+ | aExpr NOT BETWEEN SYMMETRIC bExpr AND aExpr
+ | aExpr IN inExpr
+ | aExpr NOT IN inExpr
+ | aExpr subqueryOp subType selectWithParens
+ | aExpr subqueryOp subType LP_ aExpr RP_
+ | UNIQUE selectWithParens
+ | aExpr IS DOCUMENT
+ | aExpr IS NOT DOCUMENT
+ | aExpr IS NORMALIZED
+ | aExpr IS unicodeNormalForm NORMALIZED
+ | aExpr IS NOT NORMALIZED
+ | aExpr IS NOT unicodeNormalForm NORMALIZED
+ | aExpr logicalOperator aExpr
+ | DEFAULT
+ ;
+
+bExpr
+ : cExpr
+ | bExpr TYPE_CAST_ typeName
+ | PLUS_ bExpr
+ | MINUS_ bExpr
+ | bExpr qualOp bExpr
+ | qualOp bExpr
+ | bExpr qualOp
+ | bExpr IS DISTINCT FROM bExpr
+ | bExpr IS NOT DISTINCT FROM bExpr
+ | bExpr IS OF LP_ typeList RP_
+ | bExpr IS NOT OF LP_ typeList RP_
+ | bExpr IS DOCUMENT
+ | bExpr IS NOT DOCUMENT
+ ;
+
+cExpr
+ : parameterMarker
+ | columnref
+ | aexprConst
+ | PARAM indirectionEl?
+ | caseExpr
+ | funcExpr
+ | selectWithParens
+ | selectWithParens indirection
+ | EXISTS selectWithParens
+ | ARRAY selectWithParens
+ | ARRAY arrayExpr
+ | explicitRow
+ | implicitRow
+ | GROUPING LP_ exprList RP_
+ ;
+
+indirection
+ : indirectionEl
+ | indirection indirectionEl
+ ;
+
+optIndirection
+ : optIndirection indirectionEl |
+ ;
+
+indirectionEl
+ : DOT_ attrName
+ | DOT_ ASTERISK_
+ | LBT_ aExpr RBT_
+ | LBT_ sliceBound? COLON_ sliceBound? RBT_
+ ;
+
+sliceBound
+ : aExpr
+ ;
+
+inExpr
+ : selectWithParens | LP_ exprList RP_
+ ;
+
+caseExpr
+ : CASE caseArg? whenClauseList caseDefault? END
+ ;
+
+whenClauseList
+ : whenClause
+ | whenClauseList whenClause
+ ;
+
+whenClause
+ : WHEN aExpr THEN aExpr
+ ;
+
+caseDefault
+ : ELSE aExpr
+ ;
+
+caseArg
+ : aExpr
+ ;
+
+columnref
+ : colId
+ | colId indirection
+ ;
+
+qualOp
+ : mathOperator
+ | TILDE_TILDE_
+ | NOT_TILDE_TILDE_
+ | OPERATOR LP_ anyOperator RP_
+ ;
+
+subqueryOp
+ : allOp
+ | OPERATOR LP_ anyOperator RP_
+ | LIKE
+ | NOT LIKE
+ | ILIKE
+ | NOT ILIKE
+ ;
+
+allOp
+ : mathOperator
+ ;
+
+mathOperator
+ : PLUS_
+ | MINUS_
+ | ASTERISK_
+ | SLASH_
+ | MOD_
+ | CARET_
+ | LT_
+ | GT_
+ | EQ_
+ | LTE_
+ | GTE_
+ | NEQ_
+ ;
+
+qualAllOp
+ : allOp
+ | OPERATOR LP_ anyOperator RP_
+ ;
+
+ascDesc
+ : ASC | DESC
+ ;
+
+anyOperator
+ : allOp | colId DOT_ anyOperator
+ ;
+
+frameClause
+ : RANGE frameExtent windowExclusionClause?
+ | ROWS frameExtent windowExclusionClause?
+ | GROUPS frameExtent windowExclusionClause?
+ ;
+
+frameExtent
+ : frameBound
+ | BETWEEN frameBound AND frameBound
+ ;
+
+frameBound
+ : UNBOUNDED PRECEDING
+ | UNBOUNDED FOLLOWING
+ | CURRENT ROW
+ | aExpr PRECEDING
+ | aExpr FOLLOWING
+ ;
+
+windowExclusionClause
+ : EXCLUDE CURRENT ROW
+ | EXCLUDE GROUP
+ | EXCLUDE TIES
+ | EXCLUDE NO OTHERS
+ ;
+
+row
+ : ROW LP_ exprList RP_
+ | ROW LP_ RP_
+ | LP_ exprList COMMA_ aExpr RP_
+ ;
+
+explicitRow
+ : ROW LP_ exprList RP_
+ | ROW LP_ RP_
+ ;
+
+implicitRow
+ : LP_ exprList COMMA_ aExpr RP_
+ ;
+
+subType
+ : ANY | SOME | ALL
+ ;
+
+arrayExpr
+ : LBT_ exprList RBT_
+ | LBT_ arrayExprList RBT_
+ | LBT_ RBT_
+ ;
+
+arrayExprList
+ : arrayExpr | arrayExprList COMMA_ arrayExpr
+ ;
+
+funcArgList
+ : funcArgExpr
+ | funcArgList COMMA_ funcArgExpr
+ ;
+
+paramName
+ : typeFunctionName
+ ;
+
+funcArgExpr
+ : aExpr
+ | paramName CQ_ aExpr
+ | paramName GTE_ aExpr
+ ;
+
+typeList
+ : typeName
+ | typeList COMMA_ typeName
+ ;
+
+funcApplication
+ : funcName LP_ RP_
+ | funcName LP_ funcArgList sortClause? RP_
+ | funcName LP_ VARIADIC funcArgExpr sortClause? RP_
+ | funcName LP_ funcArgList COMMA_ VARIADIC funcArgExpr sortClause? RP_
+ | funcName LP_ ALL funcArgList sortClause? RP_
+ | funcName LP_ DISTINCT funcArgList sortClause? RP_
+ | funcName LP_ ASTERISK_ RP_
;
-comparisonOperator
- : EQ_ | GTE_ | GT_ | LTE_ | LT_ | NEQ_
+funcName
+ : typeFunctionName | colId indirection
;
-predicate
- : bitExpr NOT? IN subquery
- | bitExpr NOT? IN LP_ expr (COMMA_ expr)* RP_
- | bitExpr NOT? BETWEEN bitExpr AND predicate
- | bitExpr NOT? LIKE simpleExpr (ESCAPE simpleExpr)?
- | bitExpr (TILDE_TILDE_ | NOT_TILDE_TILDE_) simpleExpr (ESCAPE simpleExpr)?
- | bitExpr
- ;
-
-bitExpr
- : bitExpr VERTICAL_BAR_ bitExpr
- | bitExpr AMPERSAND_ bitExpr
- | bitExpr SIGNED_LEFT_SHIFT_ bitExpr
- | bitExpr SIGNED_RIGHT_SHIFT_ bitExpr
- | bitExpr PLUS_ bitExpr
- | bitExpr MINUS_ bitExpr
- | bitExpr ASTERISK_ bitExpr
- | bitExpr SLASH_ bitExpr
- | bitExpr MOD_ bitExpr
- | bitExpr CARET_ bitExpr
- | simpleExpr
- ;
-
-simpleExpr
- : functionCall
- | parameterMarker
- | literals
- | columnName
- | simpleExpr COLLATE (STRING_ | identifier)
- | simpleExpr OR_ simpleExpr
- | (PLUS_ | MINUS_ | TILDE_ | NOT_ | BINARY) simpleExpr
- | ROW? LP_ expr (COMMA_ expr)* RP_
- | EXISTS? subquery
- | LBE_ identifier expr RBE_
- | caseExpression
- | CURRENT_USER
+aexprConst
+ : NUMBER_
+ | STRING_
+ | funcName STRING_
+ | funcName LP_ funcArgList sortClause? RP_ STRING_
+ | TRUE
+ | FALSE
+ | NULL
+ ;
+
+qualifiedName
+ : colId | colId indirection
;
-functionCall
- : aggregationFunction | specialFunction | regularFunction
+colId
+ : identifier
;
-aggregationFunction
- : aggregationFunctionName LP_ distinct? (expr (COMMA_ expr)* | ASTERISK_)? RP_ filterClause_?
+typeFunctionName
+ : identifier | unreservedWord | typeFuncNameKeyword
;
-aggregationFunctionName
- : MAX | MIN | SUM | COUNT | AVG
+functionTable
+ : functionExprWindowless optOrdinality
+ | ROWS FROM LP_ rowsFromList RP_ optOrdinality
;
-distinct
- : DISTINCT
+xmlTable
+ : XMLTABLE LP_ cExpr xmlExistsArgument COLUMNS xmlTableColumnList RP_
+ | XMLTABLE LP_ XMLNAMESPACES LP_ xmlNamespaceList RP_ COMMA_ cExpr xmlExistsArgument COLUMNS xmlTableColumnList RP_
+ ;
+
+xmlTableColumnList
+ : xmlTableColumnEl
+ | xmlTableColumnList COMMA_ xmlTableColumnEl
+ ;
+
+xmlTableColumnEl
+ : colId typeName
+ | colId typeName xmlTableColumnOptionList
+ | colId FOR ORDINALITY
+ ;
+
+xmlTableColumnOptionList
+ : xmlTableColumnOptionEl
+ | xmlTableColumnOptionList xmlTableColumnOptionEl
+ ;
+
+xmlTableColumnOptionEl
+ : identifier bExpr
+ | DEFAULT bExpr
+ | NOT NULL
+ | NULL
+ ;
+
+xmlNamespaceList
+ : xmlNamespaceEl
+ | xmlNamespaceList COMMA_ xmlNamespaceEl
+ ;
+
+xmlNamespaceEl
+ : bExpr AS identifier
+ | DEFAULT bExpr
+ ;
+
+funcExpr
+ : funcApplication withinGroupClause? filterClause? overClause?
+ | functionExprCommonSubexpr
+ ;
+
+withinGroupClause
+ : WITHIN GROUP LP_ sortClause RP_
+ ;
+
+filterClause
+ : FILTER LP_ WHERE aExpr RP_
+ ;
+
+functionExprWindowless
+ : funcApplication | functionExprCommonSubexpr
;
-filterClause_
- : FILTER LP_ WHERE expr RP_
+optOrdinality
+ : WITH ORDINALITY |
;
-windowFunction
- : identifier LP_ expr (COMMA_ expr)* RP_ filterClause_ OVER identifier? windowDefinition_
+functionExprCommonSubexpr
+ : COLLATION FOR LP_ aExpr RP_
+ | CURRENT_DATE
+ | CURRENT_TIME
+ | CURRENT_TIME LP_ NUMBER_ RP_
+ | CURRENT_TIMESTAMP
+ | CURRENT_TIMESTAMP LP_ NUMBER_ RP_
+ | LOCALTIME
+ | LOCALTIME LP_ NUMBER_ RP_
+ | LOCALTIMESTAMP
+ | LOCALTIMESTAMP LP_ NUMBER_ RP_
+ | CURRENT_ROLE
+ | CURRENT_USER
+ | SESSION_USER
+ | USER
+ | CURRENT_CATALOG
+ | CURRENT_SCHEMA
+ | CAST LP_ aExpr AS typeName RP_
+ | EXTRACT LP_ extractList? RP_
+ | NORMALIZE LP_ aExpr RP_
+ | NORMALIZE LP_ aExpr COMMA_ unicodeNormalForm RP_
+ | OVERLAY LP_ overlayList RP_
+ | POSITION LP_ positionList RP_
+ | SUBSTRING LP_ substrList RP_
+ | TREAT LP_ aExpr AS typeName RP_
+ | TRIM LP_ BOTH trimList RP_
+ | TRIM LP_ LEADING trimList RP_
+ | TRIM LP_ TRAILING trimList RP_
+ | TRIM LP_ trimList RP_
+ | NULLIF LP_ aExpr COMMA_ aExpr RP_
+ | COALESCE LP_ exprList RP_
+ | GREATEST LP_ exprList RP_
+ | LEAST LP_ exprList RP_
+ | XMLCONCAT LP_ exprList RP_
+ | XMLELEMENT LP_ NAME identifier RP_
+ | XMLELEMENT LP_ NAME identifier COMMA_ xmlAttributes RP_
+ | XMLELEMENT LP_ NAME identifier COMMA_ exprList RP_
+ | XMLELEMENT LP_ NAME identifier COMMA_ xmlAttributes COMMA_ exprList RP_
+ | XMLEXISTS LP_ cExpr xmlExistsArgument RP_
+ | XMLFOREST LP_ xmlAttributeList RP_
+ | XMLPARSE LP_ documentOrContent aExpr xmlWhitespaceOption RP_
+ | XMLPI LP_ NAME identifier RP_
+ | XMLPI LP_ NAME identifier COMMA_ aExpr RP_
+ | XMLROOT LP_ aExpr COMMA_ xmlRootVersion optXmlRootStandalone RP_
+ | XMLSERIALIZE LP_ documentOrContent aExpr AS simpleTypeName RP_
;
-windowDefinition_
- : pratitionClause_? orderByClause? frameClause_?
+typeName
+ : simpleTypeName optArrayBounds
+ | SETOF simpleTypeName optArrayBounds
+ | simpleTypeName ARRAY LBT_ NUMBER_ RBT_
+ | SETOF simpleTypeName ARRAY LBT_ NUMBER_ RBT_
+ | simpleTypeName ARRAY
+ | SETOF simpleTypeName ARRAY
+ ;
+
+simpleTypeName
+ : genericType
+ | numeric
+ | bit
+ | character
+ | constDatetime
+ | constInterval optInterval
+ | constInterval LP_ NUMBER_ RP_
+ ;
+
+exprList
+ : aExpr
+ | exprList COMMA_ aExpr
;
-pratitionClause_
- : PARTITION BY expr (COMMA_ expr)*
+extractList
+ : extractArg FROM aExpr
+ ;
+
+extractArg
+ : YEAR
+ | MONTH
+ | DAY
+ | HOUR
+ | MINUTE
+ | SECOND
+ | identifier
+ ;
+
+genericType
+ : typeFunctionName typeModifiers? | typeFunctionName attrs typeModifiers?
;
-frameClause_
- : (RANGE | ROWS | GROUPS) (frameStart_ | frameBetween_)
+typeModifiers
+ : LP_ exprList RP_
;
-frameStart_
- : CURRENT ROW | UNBOUNDED PRECEDING | UNBOUNDED FOLLOWING | expr PRECEDING | expr FOLLOWING
+numeric
+ : INT | INTEGER | SMALLINT | BIGINT| REAL | FLOAT optFloat | DOUBLE PRECISION | DECIMAL typeModifiers? | DEC typeModifiers? | NUMERIC typeModifiers? | BOOLEAN
+ ;
+
+constDatetime
+ : TIMESTAMP LP_ NUMBER_ RP_ optTimezone
+ | TIMESTAMP optTimezone
+ | TIME LP_ NUMBER_ RP_ optTimezone
+ | TIME optTimezone
;
-frameEnd_
- : frameStart_
+optTimezone
+ : WITH TIME ZONE
+ | WITHOUT TIME ZONE
+ |
+ ;
+
+character
+ : characterWithLength | characterWithoutLength
+ ;
+
+characterWithLength
+ : characterClause LP_ NUMBER_ RP_
+ ;
+
+characterWithoutLength
+ : characterClause
+ ;
+
+characterClause
+ : CHARACTER VARYING?
+ | CHAR VARYING?
+ | VARCHAR
+ | NATIONAL CHARACTER VARYING?
+ | NATIONAL CHAR VARYING?
+ | NCHAR VARYING?
+ ;
+
+optFloat
+ : LP_ NUMBER_ RP_ |
;
-frameBetween_
- : BETWEEN frameStart_ AND frameEnd_
+attrs
+ : DOT_ attrName | attrs DOT_ attrName
;
-specialFunction
- : windowFunction | castFunction | charFunction
+attrName
+ : colLable
;
-castFunction
- : CAST LP_ expr AS dataType RP_
+colLable
+ : identifier
;
-charFunction
- : CHAR LP_ expr (COMMA_ expr)* (USING ignoredIdentifier_)? RP_
+bit
+ : bitWithLength | bitWithoutLength
;
-regularFunction
- : regularFunctionName_ LP_ (expr (COMMA_ expr)* | ASTERISK_)? RP_
+bitWithLength
+ : BIT VARYING? LP_ exprList RP_
+ ;
+
+bitWithoutLength
+ : BIT VARYING?
+ ;
+
+constInterval
+ : INTERVAL
;
-regularFunctionName_
- : identifier | IF | CURRENT_TIMESTAMP | LOCALTIME | LOCALTIMESTAMP | INTERVAL
+optInterval
+ : YEAR
+ | MONTH
+ | DAY
+ | HOUR
+ | MINUTE
+ | intervalSecond
+ | YEAR TO MONTH
+ | DAY TO HOUR
+ | DAY TO MINUTE
+ | DAY TO intervalSecond
+ | HOUR TO MINUTE
+ | HOUR TO intervalSecond
+ | MINUTE TO intervalSecond
+ |
+ ;
+
+optArrayBounds
+ : optArrayBounds LBT_ RBT_
+ | optArrayBounds LBT_ NUMBER_ RBT_
+ |
;
-caseExpression
- : CASE simpleExpr? caseWhen_+ caseElse_?
+intervalSecond
+ : SECOND
+ | SECOND LP_ NUMBER_ RP_
+ ;
+
+unicodeNormalForm
+ : NFC | NFD | NFKC | NFKD
+ ;
+
+trimList
+ : aExpr FROM exprList
+ | FROM exprList
+ | exprList
+ ;
+
+overlayList
+ : aExpr overlayPlacing substrFrom substrFor
+ | aExpr overlayPlacing substrFrom
;
-caseWhen_
- : WHEN expr THEN expr
+overlayPlacing
+ : PLACING aExpr
;
-caseElse_
- : ELSE expr
+substrFrom
+ : FROM aExpr
;
-subquery
- : 'Default does not match anything'
+substrFor
+ : FOR aExpr
+ ;
+
+positionList
+ : bExpr IN bExpr |
+ ;
+
+substrList
+ : aExpr substrFrom substrFor
+ | aExpr substrFor substrFrom
+ | aExpr substrFrom
+ | aExpr substrFor
+ | exprList
+ |
+ ;
+
+xmlAttributes
+ : XMLATTRIBUTES LP_ xmlAttributeList RP_
+ ;
+
+xmlAttributeList
+ : xmlAttributeEl
+ | xmlAttributeList COMMA_ xmlAttributeEl
+ ;
+
+xmlAttributeEl
+ : aExpr AS identifier | aExpr
+ ;
+
+xmlExistsArgument
+ : PASSING cExpr
+ | PASSING cExpr xmlPassingMech
+ | PASSING xmlPassingMech cExpr
+ | PASSING xmlPassingMech cExpr xmlPassingMech
+ ;
+
+xmlPassingMech
+ : BY REF | BY VALUE
+ ;
+
+documentOrContent
+ : DOCUMENT | CONTENT
+ ;
+
+xmlWhitespaceOption
+ : PRESERVE WHITESPACE | STRIP WHITESPACE |
+ ;
+
+xmlRootVersion
+ : VERSION aExpr
+ | VERSION NO VALUE
+ ;
+
+optXmlRootStandalone
+ : COMMA_ STANDALONE YES
+ | COMMA_ STANDALONE NO
+ | COMMA_ STANDALONE NO VALUE
+ |
+ ;
+
+rowsFromItem
+ : functionExprWindowless optColumnDefList
+ ;
+
+rowsFromList
+ : rowsFromItem
+ | rowsFromList COMMA_ rowsFromItem
+ ;
+
+optColumnDefList
+ : AS LP_ tableFuncElementList RP_
+ ;
+
+tableFuncElementList
+ : tableFuncElement
+ | tableFuncElementList COMMA_ tableFuncElement
+ ;
+
+tableFuncElement
+ : typeName optCollateClause
;
-orderByClause
- : ORDER BY orderByItem (COMMA_ orderByItem)*
+optCollateClause
+ : COLLATE anyName
;
-orderByItem
- : (columnName | numberLiterals | expr) (ASC | DESC)?
+anyName
+ : colId | colId attrs
+ ;
+
+aliasClause
+ : AS colId LP_ nameList RP_
+ | AS colId
+ | colId LP_ nameList RP_
+ | colId
+ ;
+
+nameList
+ : name | nameList COMMA_ name
+ ;
+
+funcAliasClause
+ : aliasClause
+ | AS LP_ tableFuncElementList RP_
+ | AS colId LP_ tableFuncElementList RP_
+ | colId LP_ tableFuncElementList RP_
+ ;
+
+tablesampleClause
+ : TABLESAMPLE funcName LP_ exprList RP_ repeatableClause?
+ ;
+
+repeatableClause
+ : REPEATABLE LP_ aExpr RP_
+ ;
+
+allOrDistinct
+ : ALL | DISTINCT
+ ;
+
+sortClause
+ : ORDER BY sortbyList
+ ;
+
+sortbyList
+ : sortby (COMMA_ sortby)*
+ ;
+
+sortby
+ : aExpr USING qualAllOp nullsOrder?
+ | aExpr ascDesc? nullsOrder?
+ ;
+
+nullsOrder
+ : NULLS FIRST
+ | NULLS LAST
+ ;
+
+distinctClause
+ : DISTINCT
+ | DISTINCT ON LP_ exprList RP_
+ ;
+
+distinct
+ : DISTINCT
+ ;
+
+overClause
+ : OVER windowSpecification
+ | OVER colId
+ ;
+
+windowSpecification
+ : LP_ windowName? partitionClause? sortClause? frameClause? RP_
+ ;
+
+windowName
+ : colId
+ ;
+
+partitionClause
+ : PARTITION BY exprList
+ ;
+
+indexParams
+ : indexElem
+ | indexParams COMMA_ indexElem
+ ;
+
+indexElemOptions
+ : collate? optClass ascDesc? nullsOrder?
+ | collate? anyName reloptions ascDesc? nullsOrder?
+ ;
+
+indexElem
+ : colId indexElemOptions
+ | functionExprWindowless indexElemOptions
+ | LP_ aExpr RP_ indexElemOptions
+ ;
+
+collate
+ : COLLATE anyName
+ ;
+
+optClass
+ : anyName |
+ ;
+
+reloptions
+ : LP_ reloptionList RP_
+ ;
+
+optReloptions
+ : WITH reloptions |
+ ;
+
+reloptionList
+ : reloptionElem
+ | reloptionList COMMA_ reloptionElem
+ ;
+
+reloptionElem
+ : alias EQ_ defArg
+ | alias
+ | alias DOT_ alias EQ_ defArg
+ | alias DOT_ alias
+ ;
+
+defArg
+ : funcType
+ | reserved_keyword
+ | qualAllOp
+ | NUMBER_
+ | STRING_
+ | NONE
+ ;
+
+funcType
+ : typeName
+ | typeFunctionName attrs MOD_ TYPE
+ | SETOF typeFunctionName attrs MOD_ TYPE
+ ;
+
+selectWithParens
+ : 'Default does not match anything'
;
dataType
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/DDLStatement.g4 b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/DDLStatement.g4
index 7241a77..f5d9785 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/DDLStatement.g4
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/DDLStatement.g4
@@ -86,11 +86,11 @@ columnConstraintOption
;
checkOption
- : CHECK expr (NO INHERIT)?
+ : CHECK aExpr (NO INHERIT)?
;
defaultExpr
- : CURRENT_TIMESTAMP | expr
+ : CURRENT_TIMESTAMP | aExpr
;
sequenceOptions
@@ -241,8 +241,8 @@ columnExistClause_
;
modifyColumnSpecification
- : modifyColumn (SET DATA)? TYPE dataType collateClause_? (USING simpleExpr)?
- | modifyColumn SET DEFAULT expr
+ : modifyColumn (SET DATA)? TYPE dataType collateClause_? (USING aExpr)?
+ | modifyColumn SET DEFAULT aExpr
| modifyColumn DROP DEFAULT
| modifyColumn (SET | DROP) NOT NULL
| modifyColumn ADD GENERATED (ALWAYS | (BY DEFAULT)) AS IDENTITY (LP_ sequenceOptions RP_)?
@@ -267,7 +267,7 @@ attributeOptions
;
attributeOption
- : IDENTIFIER_ EQ_ simpleExpr
+ : IDENTIFIER_ EQ_ aExpr
;
addConstraintSpecification
@@ -279,7 +279,7 @@ tableConstraintUsingIndex
;
storageParameterWithValue
- : storageParameter EQ_ simpleExpr
+ : storageParameter EQ_ aExpr
;
storageParameter
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/DMLStatement.g4 b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/DMLStatement.g4
index 1e01310..64e3710 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/DMLStatement.g4
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/DMLStatement.g4
@@ -20,156 +20,416 @@ grammar DMLStatement;
import Symbol, Keyword, PostgreSQLKeyword, Literals, BaseRule;
insert
- : INSERT INTO tableName (AS? alias)? (insertValuesClause | insertSelectClause)
+ : withClause? INSERT INTO insertTarget insertRest optOnConflict? returningClause?
;
-insertValuesClause
- : columnNames? VALUES assignmentValues (COMMA_ assignmentValues)*
- ;
-
-insertSelectClause
- : columnNames? select
- ;
-
-update
- : UPDATE updateSpecification_? tableReferences setAssignmentsClause whereClause?
- ;
+insertTarget
+ : qualifiedName | qualifiedName AS colId
+ ;
-updateSpecification_
- : ONLY
- ;
-
-assignment
- : columnName EQ_ assignmentValue
- ;
+insertRest
+ : select
+ | OVERRIDING overrideKind VALUE select
+ | LP_ insertColumnList RP_ select
+ | LP_ insertColumnList RP_ OVERRIDING overrideKind VALUE select
+ | DEFAULT VALUES
+ ;
-setAssignmentsClause
- : SET assignment (COMMA_ assignment)*
- ;
-
-assignmentValues
- : LP_ assignmentValue (COMMA_ assignmentValue)* RP_
- | LP_ RP_
- ;
+overrideKind
+ : USER | SYSTEM
+ ;
-assignmentValue
- : expr | DEFAULT
- ;
+insertColumnList
+ : insertColumnItem
+ | insertColumnList COMMA_ insertColumnItem
+ ;
-delete
- : DELETE deleteSpecification_? (singleTableClause | multipleTablesClause) whereClause?
- ;
+insertColumnItem
+ : colId optIndirection
+ ;
-deleteSpecification_
- : ONLY
- ;
+optOnConflict
+ : ON CONFLICT optConfExpr DO UPDATE SET setClauseList whereClause?
+ | ON CONFLICT optConfExpr DO NOTHING
+ ;
-singleTableClause
- : FROM tableName (AS? alias)?
- ;
+optConfExpr
+ : LP_ indexParams RP_ whereClause?
+ | ON CONSTRAINT name
+ |
+ ;
-multipleTablesClause
- : multipleTableNames FROM tableReferences | FROM multipleTableNames USING tableReferences
+update
+ : withClause? UPDATE relationExprOptAlias SET setClauseList fromClause? whereOrCurrentClause? returningClause?
;
-multipleTableNames
- : tableName DOT_ASTERISK_? (COMMA_ tableName DOT_ASTERISK_?)*
- ;
+setClauseList
+ : setClause
+ | setClauseList COMMA_ setClause
+ ;
-select
- : unionClause
- ;
+setClause
+ : setTarget EQ_ aExpr
+ | LP_ setTargetList RP_ EQ_ aExpr
+ ;
-unionClause
- : selectClause (UNION (ALL | DISTINCT)? selectClause)*
- ;
+setTarget
+ : colId optIndirection
+ ;
-selectClause
- : SELECT duplicateSpecification? projections fromClause? whereClause? groupByClause? havingClause? orderByClause? limitClause?
- ;
+setTargetList
+ : setTarget
+ | setTargetList COMMA_ setTarget
+ ;
-duplicateSpecification
- : ALL | DISTINCT
- ;
+returningClause
+ : RETURNING targetList
+ ;
-projections
- : (unqualifiedShorthand | projection) (COMMA_ projection)*
- ;
+delete
+ : withClause? DELETE FROM relationExprOptAlias usingClause? whereOrCurrentClause? returningClause?
+ ;
+
+relationExprOptAlias
+ : relationExpr
+ | relationExpr colId
+ | relationExpr AS colId
+ ;
+
+usingClause
+ : USING fromList
+ ;
+
+select
+ : selectNoParens | selectWithParens
+ ;
+
+selectWithParens
+ : LP_ selectNoParens RP_ | LP_ selectWithParens RP_
+ ;
+
+selectNoParens
+ : selectClauseN
+ | selectClauseN sortClause
+ | selectClauseN sortClause? forLockingClause selectLimit?
+ | selectClauseN sortClause? selectLimit forLockingClause?
+ | withClause selectClauseN
+ | withClause selectClauseN sortClause
+ | withClause selectClauseN sortClause? forLockingClause selectLimit?
+ | withClause selectClauseN sortClause? selectLimit forLockingClause?
+ ;
+
+selectClauseN
+ : simpleSelect
+ | selectWithParens
+ | selectClauseN UNION allOrDistinct selectClauseN
+ | selectClauseN INTERSECT allOrDistinct selectClauseN
+ | selectClauseN EXCEPT allOrDistinct selectClauseN
+ ;
+
+simpleSelect
+ : SELECT ALL? targetList? intoClause? fromClause? whereClause? groupClause? havingClause? windowClause?
+ | SELECT distinctClause targetList intoClause? fromClause? whereClause? groupClause? havingClause? windowClause?
+ | valuesClause
+ | TABLE relationExpr
+ ;
+
+withClause
+ : WITH cteList
+ | WITH RECURSIVE cteList
+ ;
+
+intoClause
+ : INTO optTempTableName
+ ;
+
+optTempTableName
+ : TEMPORARY TABLE? qualifiedName
+ | TEMP TABLE? qualifiedName
+ | LOCAL TEMPORARY TABLE? qualifiedName
+ | LOCAL TEMP TABLE? qualifiedName
+ | GLOBAL TEMPORARY TABLE? qualifiedName
+ | GLOBAL TEMP TABLE? qualifiedName
+ | UNLOGGED TABLE? qualifiedName
+ | TABLE? qualifiedName
+ | qualifiedName
+ ;
+
+cteList
+ : commonTableExpr
+ | cteList COMMA_ commonTableExpr
+ ;
+
+commonTableExpr
+ : name optNameList AS optMaterialized LP_ preparableStmt RP_
+ ;
+
+optMaterialized
+ : MATERIALIZED | NOT MATERIALIZED |
+ ;
+
+optNameList
+ :LP_ nameList RP_ |
+ ;
+
+preparableStmt
+ : select
+ | insert
+ | update
+ | delete
+ ;
+
+forLockingClause
+ : forLockingItems | FOR READ ONLY
+ ;
+
+forLockingItems
+ : forLockingItem
+ | forLockingItems forLockingItem
+ ;
+
+forLockingItem
+ : forLockingStrength lockedRelsList? nowaitOrSkip?
+ ;
+
+nowaitOrSkip
+ : NOWAIT
+ | 'skip' LOCKED
+ ;
+
+forLockingStrength
+ : FOR UPDATE
+ | FOR NO KEY UPDATE
+ | FOR SHARE
+ | FOR KEY SHARE
+ ;
+
+lockedRelsList
+ : OF qualifiedNameList
+ ;
+
+qualifiedNameList
+ : qualifiedName
+ | qualifiedNameList COMMA_ qualifiedName
+ ;
+
+qualifiedName
+ : colId | colId indirection
+ ;
+
+selectLimit
+ : limitClause offsetClause
+ | offsetClause limitClause
+ | limitClause
+ | offsetClause
+ ;
+
+valuesClause
+ : VALUES LP_ exprList RP_
+ | valuesClause COMMA_ LP_ exprList RP_
+ ;
-projection
- : (columnName | expr) (AS? alias)? | qualifiedShorthand
- ;
+limitClause
+ : LIMIT selectLimitValue
+ | LIMIT selectLimitValue COMMA_ selectOffsetValue
+ | FETCH firstOrNext selectFetchFirstValue rowOrRows ONLY
+ | FETCH firstOrNext selectFetchFirstValue rowOrRows WITH TIES
+ | FETCH firstOrNext rowOrRows ONLY
+ | FETCH firstOrNext rowOrRows WITH TIES
+ ;
+
+offsetClause
+ : OFFSET selectOffsetValue
+ | OFFSET selectFetchFirstValue rowOrRows
+ ;
+
+selectLimitValue
+ : aExpr
+ | ALL
+ ;
+
+selectOffsetValue
+ : aExpr
+ ;
+
+selectFetchFirstValue
+ : cExpr
+ | PLUS_ NUMBER_
+ | MINUS_ NUMBER_
+ ;
+
+rowOrRows
+ : ROW | ROWS
+ ;
+
+firstOrNext
+ : FIRST | NEXT
+ ;
+
+targetList
+ : targetEl
+ | targetList COMMA_ targetEl
+ ;
+
+targetEl
+ : colId DOT_ASTERISK_
+ | aExpr AS identifier
+ | aExpr identifier
+ | aExpr
+ | ASTERISK_
+ ;
+
+groupClause
+ : GROUP BY groupByList
+ ;
+
+groupByList
+ : groupByItem (COMMA_ groupByItem)*
+ ;
+
+groupByItem
+ : aExpr
+ | emptyGroupingSet
+ | cubeClause
+ | rollupClause
+ | groupingSetsClause
+ ;
+
+emptyGroupingSet
+ : LP_ RP_
+ ;
+
+rollupClause
+ : ROLLUP LP_ exprList RP_
+ ;
+
+cubeClause
+ : CUBE LP_ exprList RP_
+ ;
+
+groupingSetsClause
+ : GROUPING SETS LP_ groupByList RP_
+ ;
+
+windowClause
+ : WINDOW windowDefinitionList
+ ;
+
+windowDefinitionList
+ : windowDefinition
+ | windowDefinitionList COMMA_ windowDefinition
+ ;
+
+windowDefinition
+ : colId AS windowSpecification
+ ;
+
+windowSpecification
+ : LP_ existingWindowName? partitionClause? sortClause? frameClause? RP_
+ ;
+
+existingWindowName
+ : colId
+ ;
+
+partitionClause
+ : PARTITION BY exprList
+ ;
+
+frameClause
+ : RANGE frameExtent optWindowExclusionClause
+ | ROWS frameExtent optWindowExclusionClause
+ | GROUPS frameExtent optWindowExclusionClause
+ ;
+
+frameExtent
+ : frameBound
+ | BETWEEN frameBound AND frameBound
+ ;
+
+frameBound
+ : UNBOUNDED PRECEDING
+ | UNBOUNDED FOLLOWING
+ | CURRENT ROW
+ | aExpr PRECEDING
+ | aExpr FOLLOWING
+ ;
+
+optWindowExclusionClause
+ : EXCLUDE CURRENT ROW
+ | EXCLUDE GROUP
+ | EXCLUDE TIES
+ | EXCLUDE NO OTHERS
+ |
+ ;
alias
: identifier | STRING_
;
-unqualifiedShorthand
- : ASTERISK_
- ;
-
-qualifiedShorthand
- : identifier DOT_ASTERISK_
- ;
-
fromClause
- : FROM tableReferences
+ : FROM fromList
;
-tableReferences
- : tableReference (COMMA_ tableReference)*
+fromList
+ : tableReference | fromList COMMA_ tableReference
;
tableReference
- : tableFactor joinedTable*
- ;
-
-tableFactor
- : tableName (AS? alias)? | subquery AS? alias columnNames? | LP_ tableReferences RP_
- ;
+ : relationExpr aliasClause?
+ | relationExpr aliasClause? tablesampleClause
+ | functionTable funcAliasClause?
+ | LATERAL functionTable funcAliasClause?
+ | xmlTable aliasClause?
+ | LATERAL xmlTable aliasClause?
+ | selectWithParens aliasClause?
+ | LATERAL selectWithParens aliasClause?
+ | tableReference joinedTable
+ | tableReference LP_ joinedTable RP_ aliasClause
+ ;
joinedTable
- : NATURAL? ((INNER | CROSS)? JOIN) tableFactor joinSpecification?
- | NATURAL? (LEFT | RIGHT | FULL) OUTER? JOIN tableFactor joinSpecification?
- ;
-
-joinSpecification
- : ON expr | USING columnNames
- ;
+ : CROSS JOIN tableReference
+ | joinType JOIN tableReference joinQual
+ | JOIN tableReference joinQual
+ | NATURAL joinType JOIN tableReference
+ | NATURAL JOIN tableReference
+ ;
-whereClause
- : WHERE expr
- ;
+joinType
+ : FULL joinOuter?
+ | LEFT joinOuter?
+ | RIGHT joinOuter?
+ | INNER
+ ;
-groupByClause
- : GROUP BY orderByItem (COMMA_ orderByItem)*
- ;
+joinOuter
+ : OUTER
+ ;
-havingClause
- : HAVING expr
- ;
+joinQual
+ : USING LP_ nameList RP_
+ | ON aExpr
+ ;
-limitClause
- : limitRowCountSyntax limitOffsetSyntax?
- | limitOffsetSyntax limitRowCountSyntax?
- ;
-limitRowCountSyntax
- : LIMIT (ALL | limitRowCount)
+relationExpr
+ : qualifiedName
+ | qualifiedName ASTERISK_
+ | ONLY qualifiedName
+ | ONLY LP_ qualifiedName RP_
;
-limitRowCount
- : numberLiterals | parameterMarker
+whereClause
+ : WHERE aExpr
;
-limitOffsetSyntax
- : OFFSET limitOffset (ROW | ROWS)?
- ;
+whereOrCurrentClause
+ : whereClause
+ | WHERE CURRENT OF cursorName
+ ;
-limitOffset
- : numberLiterals | parameterMarker
- ;
-subquery
- : LP_ unionClause RP_
+havingClause
+ : HAVING aExpr
;
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Keyword.g4 b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Keyword.g4
index 6bf36a3..1d1e16a 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Keyword.g4
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Keyword.g4
@@ -423,26 +423,6 @@ MICROSECOND
: M I C R O S E C O N D
;
-MAX
- : M A X
- ;
-
-MIN
- : M I N
- ;
-
-SUM
- : S U M
- ;
-
-COUNT
- : C O U N T
- ;
-
-AVG
- : A V G
- ;
-
DEFAULT
: D E F A U L T
;
@@ -551,3 +531,111 @@ NUMERIC
TEXT
: T E X T
;
+
+REPEATABLE
+ : R E P E A T A B L E
+ ;
+
+CURRENT_DATE
+ : C U R R E N T UL_ D A T E
+ ;
+
+CURRENT_TIME
+ : C U R R E N T UL_ T I M E
+ ;
+
+CURRENT_TIMESTAMP
+ : C U R R E N T UL_ T I M E S T A M P
+ ;
+
+NULLIF
+ : N U L L I F
+ ;
+
+VARYING
+ : V A R Y I N G
+ ;
+
+NATIONAL
+ : N A T I O N A L
+ ;
+
+NCHAR
+ : N C H A R
+ ;
+
+VALUE
+ : V A L U E
+ ;
+
+BOTH
+ : B O T H
+ ;
+
+LEADING
+ : L E A D I N G
+ ;
+
+TRAILING
+ : T R A I L I N G
+ ;
+
+COALESCE
+ : C O A L E S C E
+ ;
+
+INTERSECT
+ : I N T E R S E C T
+ ;
+
+EXCEPT
+ : E X C E P T
+ ;
+
+TIES
+ : T I E S
+ ;
+
+FETCH
+ : F E T C H
+ ;
+
+CUBE
+ : C U B E
+ ;
+
+GROUPING
+ : G R O U P I N G
+ ;
+
+SETS
+ : S E T S
+ ;
+
+WINDOW
+ : W I N D O W
+ ;
+
+OTHERS
+ : O T H E R S
+ ;
+
+OVERLAPS
+ : O V E R L A P S
+ ;
+
+SOME
+ : S O M E
+ ;
+
+AT
+ : A T
+ ;
+
+DEC
+ : D E C
+ ;
+
+END
+ : E N D
+ ;
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Literals.g4 b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Literals.g4
index 09df0ec..186e790 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Literals.g4
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Literals.g4
@@ -24,7 +24,7 @@ IDENTIFIER_
| DQ_ ~'"'+ DQ_
;
-STRING_
+STRING_
: SQ_ ('\\'. | '\'\'' | ~('\'' | '\\'))* SQ_
;
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/PostgreSQLKeyword.g4 b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/PostgreSQLKeyword.g4
index 4754c3b..2fa4975 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/PostgreSQLKeyword.g4
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/PostgreSQLKeyword.g4
@@ -622,3 +622,761 @@ TSTZRANGE
DATERANGE
: D A T E R A N G E
;
+
+TABLESAMPLE
+ : T A B L E S A M P L E
+ ;
+
+ORDINALITY
+ : O R D I N A L I T Y
+ ;
+
+CURRENT_ROLE
+ : C U R R E N T UL_ R O L E
+ ;
+
+CURRENT_CATALOG
+ : C U R R E N T UL_ C A T A L O G
+ ;
+
+CURRENT_SCHEMA
+ : C U R R E N T UL_ S C H E M A
+ ;
+
+NORMALIZE
+ : N O R M A L I Z E
+ ;
+
+OVERLAY
+ : O V E R L A Y
+ ;
+
+XMLCONCAT
+ : X M L C O N C A T
+ ;
+
+XMLELEMENT
+ : X M L E L E M E N T
+ ;
+
+XMLEXISTS
+ : X M L E X I S T S
+ ;
+
+XMLFOREST
+ : X M L F O R E S T
+ ;
+
+XMLPARSE
+ : X M L P A R S E
+ ;
+
+XMLPI
+ : X M L P I
+ ;
+
+XMLROOT
+ : X M L R O O T
+ ;
+
+XMLSERIALIZE
+ : X M L S E R I A L I Z E
+ ;
+
+TREAT
+ : T R E A T
+ ;
+
+SETOF
+ : S E T O F
+ ;
+
+NFC
+ : N F C
+ ;
+
+NFD
+ : N F D
+ ;
+
+NFKC
+ : N F K C
+ ;
+
+NFKD
+ : N F K D
+ ;
+
+XMLATTRIBUTES
+ : X M L A T T R I B U T E S
+ ;
+
+REF
+ : R E F
+ ;
+
+PASSING
+ : P A S S I N G
+ ;
+
+VERSION
+ : V E R S I O N
+ ;
+
+YES
+ : Y E S
+ ;
+
+STANDALONE
+ : S T A N D A L O N E
+ ;
+
+GREATEST
+ : G R E A T E S T
+ ;
+
+LEAST
+ : L E A S T
+ ;
+
+MATERIALIZED
+ : M A T E R I A L I Z E D
+ ;
+
+OPERATOR
+ : O P E R A T O R
+ ;
+
+SHARE
+ : S H A R E
+ ;
+
+ROLLUP
+ : R O L L U P
+ ;
+
+ILIKE
+ : I L I K E
+ ;
+
+SIMILAR
+ : S I M I L A R
+ ;
+
+ISNULL
+ : I S N U L L
+ ;
+
+NOTNULL
+ : N O T N U L L
+ ;
+
+SYMMETRIC
+ : S Y M M E T R I C
+ ;
+
+DOCUMENT
+ : D O C U M E N T
+ ;
+
+NORMALIZED
+ : N O R M A L I Z E D
+ ;
+
+ASYMMETRIC
+ : A S Y M M E T R I C
+ ;
+
+VARIADIC
+ : V A R I A D I C
+ ;
+
+NOWAIT
+ : N O W A I T
+ ;
+
+LOCKED
+ : L O C K E D
+ ;
+
+XMLTABLE
+ : X M L T A B L E
+ ;
+
+COLUMNS
+ : C O L U M N S
+ ;
+
+CONTENT
+ : C O N T E N T
+ ;
+
+STRIP
+ : S T R I P
+ ;
+
+WHITESPACE
+ : W H I T E S P A C E
+ ;
+
+XMLNAMESPACES
+ : X M L N A M E S P A C E S
+ ;
+
+PLACING
+ : P L A C I N G
+ ;
+
+RETURNING
+ : R E T U R N I N G
+ ;
+
+LATERAL
+ : L A T E R A L
+ ;
+
+NONE
+ : N O N E
+ ;
+
+ANALYSE
+ : A N A L Y S E
+ ;
+
+ANALYZE
+ : A N A L Y Z E
+ ;
+
+CONFLICT
+ : C O N F L I C T
+ ;
+
+OVERRIDING
+ : O V E R R I D I N G
+ ;
+
+SYSTEM
+ : S Y S T E M
+ ;
+
+ABORT
+ : A B O R T
+ ;
+
+ABSOLUTE
+ : A B S O L U T E
+ ;
+
+ACCESS
+ : A C C E S S
+ ;
+
+AFTER
+ : A F T E R
+ ;
+
+AGGREGATE
+ : A G G R E G A T E
+ ;
+
+ALSO
+ : A L S O
+ ;
+
+ATTACH
+ : A T T A C H
+ ;
+
+ATTRIBUTE
+ : A T T R I B U T E
+ ;
+
+BACKWARD
+ : B A C K W A R D
+ ;
+
+BEFORE
+ : B E F O R E
+ ;
+
+ASSERTION
+ : A S S E R T I O N
+ ;
+
+ASSIGNMENT
+ : A S S I G N M E N T
+ ;
+
+CONTINUE
+ : C O N T I N U E
+ ;
+
+CONVERSION
+ : C O N V E R S I O N
+ ;
+
+COPY
+ : C O P Y
+ ;
+
+COST
+ : C O S T
+ ;
+
+CSV
+ : C S V
+ ;
+
+CALLED
+ : C A L L E D
+ ;
+
+CATALOG
+ : C A T A L O G
+ ;
+
+CHAIN
+ : C H A I N
+ ;
+
+CHECKPOINT
+ : C H E C K P O I N T
+ ;
+
+CLASS
+ : C L A S S
+ ;
+
+CONFIGURATION
+ : C O N F I G U R A T I O N
+ ;
+
+COMMENT
+ : C O M M E N T
+ ;
+
+DETACH
+ : D E T A C H
+ ;
+
+DICTIONARY
+ : D I C T I O N A R Y
+ ;
+
+EXPRESSION
+ : E X P R E S S I O N
+ ;
+
+INSENSITIVE
+ : I N S E N S I T I V E
+ ;
+
+DISCARD
+ : D I S C A R D
+ ;
+
+OFF
+ : O F F
+ ;
+
+INSTEAD
+ : I N S T E A D
+ ;
+
+EXPLAIN
+ : E X P L A I N
+ ;
+
+INPUT
+ : I N P U T
+ ;
+
+INLINE
+ : I N L I N E
+ ;
+
+PARALLEL
+ : P A R A L L E L
+ ;
+
+LEAKPROOF
+ : L E A K P R O O F
+ ;
+
+COMMITTED
+ : C O M M I T T E D
+ ;
+
+ENCODING
+ : E N C O D I N G
+ ;
+
+IMPLICIT
+ : I M P L I C I T
+ ;
+
+DELIMITER
+ : D E L I M I T E R
+ ;
+
+CURSOR
+ : C U R S O R
+ ;
+EACH
+ : E A C H
+ ;
+EVENT
+ : E V E N T
+ ;
+
+DEALLOCATE
+ : D E A L L O C A T E
+ ;
+
+CONNECTION
+ : C O N N E C T I O N
+ ;
+
+DECLARE
+ : D E C L A R E
+ ;
+
+FAMILY
+ : F A M I L Y
+ ;
+
+FORWARD
+ : F O R W A R D
+ ;
+
+EXCLUSIVE
+ : E X C L U S I V E
+ ;
+
+FUNCTIONS
+ : F U N C T I O N S
+ ;
+
+LOCATION
+ : L O C A T I O N
+ ;
+
+LABEL
+ : L A B E L
+ ;
+
+DELIMITERS
+ : D E L I M I T E R S
+ ;
+
+HANDLER
+ : H A N D L E R
+ ;
+
+HEADER
+ : H E A D E R
+ ;
+
+IMMUTABLE
+ : I M M U T A B L E
+ ;
+
+GRANTED
+ : G R A N T E D
+ ;
+
+HOLD
+ : H O L D
+ ;
+
+MAPPING
+ : M A P P I N G
+ ;
+
+OLD
+ : O L D
+ ;
+
+METHOD
+ : M E T H O D
+ ;
+
+LOAD
+ : L O A D
+ ;
+
+LISTEN
+ : L I S T E N
+ ;
+
+MODE
+ : M O D E
+ ;
+
+MOVE
+ : M O V E
+ ;
+
+PROCEDURAL
+ : P R O C E D U R A L
+ ;
+
+PARSER
+ : P A R S E R
+ ;
+
+PROCEDURES
+ : P R O C E D U R E S
+ ;
+
+ENCRYPTED
+ : E N C R Y P T E D
+ ;
+
+PUBLICATION
+ : P U B L I C A T I O N
+ ;
+
+PROGRAM
+ : P R O G R A M
+ ;
+
+REFERENCING
+ : R E F E R E N C I N G
+ ;
+
+PLANS
+ : P L A N S
+ ;
+
+REINDEX
+ : R E I N D E X
+ ;
+
+PRIOR
+ : P R I O R
+ ;
+
+PASSWORD
+ : P A S S W O R D
+ ;
+
+RELATIVE
+ : R E L A T I V E
+ ;
+
+QUOTE
+ : Q U O T E
+ ;
+
+ROUTINES
+ : R O U T I N E S
+ ;
+
+REPLACE
+ : R E P L A C E
+ ;
+
+SNAPSHOT
+ : S N A P S H O T
+ ;
+
+REFRESH
+ : R E F R E S H
+ ;
+
+PREPARE
+ : P R E P A R E
+ ;
+
+OPTIONS
+ : O P T I O N S
+ ;
+
+IMPORT
+ : I M P O R T
+ ;
+
+INVOKER
+ : I N V O K E R
+ ;
+
+NEW
+ : N E W
+ ;
+
+//SKIP
+// : S K I P
+// ;
+
+PREPARED
+ : P R E P A R E D
+ ;
+
+SCROLL
+ : S C R O L L
+ ;
+
+SEQUENCES
+ : S E Q U E N C E S
+ ;
+
+SYSID
+ : S Y S I D
+ ;
+
+REASSIGN
+ : R E A S S I G N
+ ;
+
+SERVER
+ : S E R V E R
+ ;
+
+SUBSCRIPTION
+ : S U B S C R I P T I O N
+ ;
+
+SEARCH
+ : S E A R C H
+ ;
+
+SCHEMAS
+ : S C H E M A S
+ ;
+
+RECHECK
+ : R E C H E C K
+ ;
+
+POLICY
+ : P O L I C Y
+ ;
+
+NOTIFY
+ : N O T I F Y
+ ;
+
+LOCK
+ : L O C K
+ ;
+
+RELEASE
+ : R E L E A S E
+ ;
+
+SERIALIZABLE
+ : S E R I A L I Z A B L E
+ ;
+
+RETURNS
+ : R E T U R N S
+ ;
+
+STATEMENT
+ : S T A T E M E N T
+ ;
+
+STDIN
+ : S T D I N
+ ;
+
+STDOUT
+ : S T D O U T
+ ;
+
+TABLES
+ : T A B L E S
+ ;
+
+SUPPORT
+ : S U P P O R T
+ ;
+
+STABLE
+ : S T A B L E
+ ;
+
+TEMPLATE
+ : T E M P L A T E
+ ;
+
+UNENCRYPTED
+ : U N E N C R Y P T E D
+ ;
+
+VIEWS
+ : V I E W S
+ ;
+
+UNCOMMITTED
+ : U N C O M M I T T E D
+ ;
+
+TRANSFORM
+ : T R A N S F O R M
+ ;
+
+UNLISTEN
+ : U N L I S T E N
+ ;
+
+TRUSTED
+ : T R U S T E D
+ ;
+
+VALIDATOR
+ : V A L I D A T O R
+ ;
+
+UNTIL
+ : U N T I L
+ ;
+
+VACUUM
+ : V A C U U M
+ ;
+
+VOLATILE
+ : V O L A T I L E
+ ;
+
+STORED
+ : S T O R E D
+ ;
+
+WRITE
+ : W R I T E
+ ;
+
+STRICT
+ : S T R I C T
+ ;
+
+TYPES
+ : T Y P E S
+ ;
+
+WRAPPER
+ : W R A P P E R
+ ;
+
+WORK
+ : W O R K
+ ;
+
+FREEZE
+ : F R E E Z E
+ ;
+
+AUTHORIZATION
+ : A U T H O R I Z A T I O N
+ ;
+
+VERBOSE
+ : V E R B O S E
+ ;
+
+PARAM
+ : P A R A M
+ ;
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Symbol.g4 b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Symbol.g4
index 685bd20..f1b12dc 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Symbol.g4
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/antlr4/imports/postgresql/Symbol.g4
@@ -38,6 +38,7 @@ DOT_ASTERISK_: '.*';
SAFE_EQ_: '<=>';
DEQ_: '==';
EQ_: '=';
+CQ_: ':=';
NEQ_: '<>' | '!=';
GT_: '>';
GTE_: '>=';
@@ -59,3 +60,4 @@ AT_: '@';
SEMI_: ';';
TILDE_TILDE_: '~~';
NOT_TILDE_TILDE_: '!~~';
+TYPE_CAST_: '::';
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/java/org/apache/shardingsphere/sql/parser/postgresql/visitor/PostgreSQLVisitor.java b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/java/org/apache/shardingsphere/sql/parser/postgresql/visitor/PostgreSQLVisitor.java
index 0cbe6a9..f02248a 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/java/org/apache/shardingsphere/sql/parser/postgresql/visitor/PostgreSQLVisitor.java
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/java/org/apache/shardingsphere/sql/parser/postgresql/visitor/PostgreSQLVisitor.java
@@ -20,45 +20,36 @@ package org.apache.shardingsphere.sql.parser.postgresql.visitor;
import com.google.common.base.Joiner;
import lombok.AccessLevel;
import lombok.Getter;
-import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.apache.shardingsphere.sql.parser.api.ASTNode;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementBaseVisitor;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AggregationFunctionContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.BitExprContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.BitValueLiteralsContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.BooleanLiteralsContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.BooleanPrimaryContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CaseExpressionContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CastFunctionContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CharFunctionContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AExprContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AexprConstContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AscDescContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AttrNameContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.BExprContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.CExprContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColumnNameContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColumnNamesContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColumnrefContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DataTypeContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DataTypeLengthContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DataTypeNameContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ExprContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.FunctionCallContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.HexadecimalLiteralsContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.FuncApplicationContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.FuncExprContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.FunctionExprCommonSubexprContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IdentifierContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InExprContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.IndexNameContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.LiteralsContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.NullValueLiteralsContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.NumberLiteralsContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.OrderByClauseContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.OrderByItemContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.OwnerContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ParameterMarkerContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.PredicateContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.RegularFunctionContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SchemaNameContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SimpleExprContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SpecialFunctionContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.StringLiteralsContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SubqueryContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SortClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SortbyContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableNameContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableNamesContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.UnreservedWordContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.WindowFunctionContext;
import org.apache.shardingsphere.sql.parser.sql.constant.AggregationType;
import org.apache.shardingsphere.sql.parser.sql.constant.OrderDirection;
import org.apache.shardingsphere.sql.parser.sql.predicate.PredicateBuilder;
@@ -68,11 +59,10 @@ import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.ExpressionSegme
import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.complex.CommonExpressionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.simple.LiteralExpressionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
-import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.subquery.SubqueryExpressionSegment;
-import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.subquery.SubquerySegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.AggregationDistinctProjectionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.AggregationProjectionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.ExpressionProjectionSegment;
+import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.ProjectionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.OrderBySegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.ColumnOrderByItemSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.ExpressionOrderByItemSegment;
@@ -91,19 +81,16 @@ import org.apache.shardingsphere.sql.parser.sql.segment.generic.DataTypeSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.generic.OwnerSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.generic.table.SimpleTableSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.generic.table.TableNameSegment;
-import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
-import org.apache.shardingsphere.sql.parser.sql.util.SQLUtil;
import org.apache.shardingsphere.sql.parser.sql.value.collection.CollectionValue;
import org.apache.shardingsphere.sql.parser.sql.value.identifier.IdentifierValue;
import org.apache.shardingsphere.sql.parser.sql.value.keyword.KeywordValue;
+import org.apache.shardingsphere.sql.parser.sql.value.literal.LiteralValue;
import org.apache.shardingsphere.sql.parser.sql.value.literal.impl.BooleanLiteralValue;
import org.apache.shardingsphere.sql.parser.sql.value.literal.impl.NumberLiteralValue;
-import org.apache.shardingsphere.sql.parser.sql.value.literal.impl.OtherLiteralValue;
import org.apache.shardingsphere.sql.parser.sql.value.literal.impl.StringLiteralValue;
import org.apache.shardingsphere.sql.parser.sql.value.parametermarker.ParameterMarkerValue;
import java.util.Collection;
-import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
@@ -121,62 +108,11 @@ public abstract class PostgreSQLVisitor extends PostgreSQLStatementBaseVisitor<A
}
@Override
- public final ASTNode visitLiterals(final LiteralsContext ctx) {
- if (null != ctx.stringLiterals()) {
- return visit(ctx.stringLiterals());
- }
- if (null != ctx.numberLiterals()) {
- return visit(ctx.numberLiterals());
- }
- if (null != ctx.hexadecimalLiterals()) {
- return visit(ctx.hexadecimalLiterals());
- }
- if (null != ctx.bitValueLiterals()) {
- return visit(ctx.bitValueLiterals());
- }
- if (null != ctx.booleanLiterals()) {
- return visit(ctx.booleanLiterals());
- }
- if (null != ctx.nullValueLiterals()) {
- return visit(ctx.nullValueLiterals());
- }
- throw new IllegalStateException("Literals must have string, number, dateTime, hex, bit, boolean or null.");
- }
-
- @Override
- public final ASTNode visitStringLiterals(final StringLiteralsContext ctx) {
- return new StringLiteralValue(ctx.getText());
- }
-
- @Override
public final ASTNode visitNumberLiterals(final NumberLiteralsContext ctx) {
return new NumberLiteralValue(ctx.getText());
}
@Override
- public final ASTNode visitHexadecimalLiterals(final HexadecimalLiteralsContext ctx) {
- // TODO deal with hexadecimalLiterals
- return new OtherLiteralValue(ctx.getText());
- }
-
- @Override
- public final ASTNode visitBitValueLiterals(final BitValueLiteralsContext ctx) {
- // TODO deal with bitValueLiterals
- return new OtherLiteralValue(ctx.getText());
- }
-
- @Override
- public final ASTNode visitBooleanLiterals(final BooleanLiteralsContext ctx) {
- return new BooleanLiteralValue(ctx.getText());
- }
-
- @Override
- public final ASTNode visitNullValueLiterals(final NullValueLiteralsContext ctx) {
- // TODO deal with nullValueLiterals
- return new OtherLiteralValue(ctx.getText());
- }
-
- @Override
public final ASTNode visitIdentifier(final IdentifierContext ctx) {
UnreservedWordContext unreservedWord = ctx.unreservedWord();
return null != unreservedWord ? visit(unreservedWord) : new IdentifierValue(ctx.getText());
@@ -236,270 +172,177 @@ public abstract class PostgreSQLVisitor extends PostgreSQLStatementBaseVisitor<A
}
@Override
- public final ASTNode visitExpr(final ExprContext ctx) {
- if (null != ctx.booleanPrimary()) {
- return visit(ctx.booleanPrimary());
+ public ASTNode visitAExpr(final AExprContext ctx) {
+ if (null != ctx.cExpr()) {
+ return visit(ctx.cExpr());
}
+
+ if (null != ctx.BETWEEN() && null == ctx.NOT()) {
+ return createBetweenSegment(ctx);
+ }
+ if (null != ctx.IN() && null == ctx.NOT()) {
+ return createInSegment(ctx);
+ }
+
+ if (null != ctx.comparisonOperator()) {
+ ASTNode left = visit(ctx.aExpr(0));
+ if (left instanceof ColumnSegment) {
+ ColumnSegment columnSegment = (ColumnSegment) left;
+ ASTNode right = visit(ctx.aExpr(1));
+ PredicateRightValue value = right instanceof ColumnSegment ? (PredicateRightValue) right
+ : new PredicateCompareRightValue(ctx.comparisonOperator().getText(), (ExpressionSegment) right);
+ PredicateSegment predicate = new PredicateSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), columnSegment, value);
+ return predicate;
+ }
+ visit(ctx.aExpr(1));
+ return new LiteralExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+ }
+
if (null != ctx.logicalOperator()) {
- return new PredicateBuilder(visit(ctx.expr(0)), visit(ctx.expr(1)), ctx.logicalOperator().getText()).mergePredicate();
+ return new PredicateBuilder(visit(ctx.aExpr(0)), visit(ctx.aExpr(1)), ctx.logicalOperator().getText()).mergePredicate();
}
- // TODO deal with XOR
- return visit(ctx.expr().get(0));
+
+ if (null != ctx.optIndirection()) {
+ return visit(ctx.aExpr(0));
+ }
+ super.visitAExpr(ctx);
+ return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
}
@Override
- public final ASTNode visitBooleanPrimary(final BooleanPrimaryContext ctx) {
- if (null != ctx.comparisonOperator() || null != ctx.SAFE_EQ_()) {
- return createCompareSegment(ctx);
+ public ASTNode visitCExpr(final CExprContext ctx) {
+ if (null != ctx.columnref()) {
+ return visit(ctx.columnref());
}
- if (null != ctx.predicate()) {
- return visit(ctx.predicate());
+ if (null != ctx.parameterMarker()) {
+ return new ParameterMarkerExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ((ParameterMarkerValue) visit(ctx.parameterMarker())).getValue());
}
- if (null != ctx.subquery()) {
- return new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()));
+
+ if (null != ctx.aexprConst()) {
+ ASTNode astNode = visit(ctx.aexprConst());
+ if (astNode instanceof StringLiteralValue || astNode instanceof BooleanLiteralValue || astNode instanceof NumberLiteralValue) {
+ return new LiteralExpressionSegment(ctx.aexprConst().start.getStartIndex(), ctx.aexprConst().stop.getStopIndex(), ((LiteralValue) astNode).getValue());
+ }
+ return astNode;
}
- //TODO deal with IS NOT? (TRUE | FALSE | UNKNOWN | NULL)
- return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+ super.visitCExpr(ctx);
+ return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText());
}
- private ASTNode createCompareSegment(final BooleanPrimaryContext ctx) {
- ASTNode leftValue = visit(ctx.booleanPrimary());
- if (!(leftValue instanceof ColumnSegment)) {
- return leftValue;
+ @Override
+ public ASTNode visitAexprConst(final AexprConstContext ctx) {
+ if (null != ctx.NUMBER_()) {
+ return new NumberLiteralValue(ctx.NUMBER_().getText());
}
- PredicateRightValue rightValue = (PredicateRightValue) createPredicateRightValue(ctx);
- return new PredicateSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (ColumnSegment) leftValue, rightValue);
- }
-
- private ASTNode createPredicateRightValue(final BooleanPrimaryContext ctx) {
- if (null != ctx.subquery()) {
- new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()));
+ if (null != ctx.STRING_()) {
+ return new StringLiteralValue(ctx.STRING_().getText());
}
- ASTNode rightValue = visit(ctx.predicate());
- return createPredicateRightValue(ctx, rightValue);
- }
-
- private ASTNode createPredicateRightValue(final BooleanPrimaryContext ctx, final ASTNode rightValue) {
- if (rightValue instanceof ColumnSegment) {
- return rightValue;
+ if (null != ctx.FALSE()) {
+ return new BooleanLiteralValue(ctx.FALSE().getText());
+ }
+ if (null != ctx.TRUE()) {
+ return new BooleanLiteralValue(ctx.TRUE().getText());
}
- return rightValue instanceof SubquerySegment ? new PredicateCompareRightValue(ctx.comparisonOperator().getText(), new SubqueryExpressionSegment((SubquerySegment) rightValue))
- : new PredicateCompareRightValue(ctx.comparisonOperator().getText(), (ExpressionSegment) rightValue);
+ return new CommonExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText());
}
@Override
- public final ASTNode visitPredicate(final PredicateContext ctx) {
- if (null != ctx.IN() && null == ctx.NOT()) {
- return createInSegment(ctx);
- }
- if (null != ctx.BETWEEN() && null == ctx.NOT()) {
- return createBetweenSegment(ctx);
- }
- if (1 == ctx.children.size()) {
- return visit(ctx.bitExpr(0));
+ public ASTNode visitColumnref(final ColumnrefContext ctx) {
+ if (null != ctx.indirection()) {
+ AttrNameContext attrName = ctx.indirection().indirectionEl().attrName();
+ ColumnSegment result = new ColumnSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(attrName.getText()));
+ OwnerSegment owner = new OwnerSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+ result.setOwner(owner);
+ return result;
}
- return visitRemainPredicate(ctx);
+ ColumnSegment result = new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+ return result;
}
- private PredicateSegment createInSegment(final PredicateContext ctx) {
- ColumnSegment column = (ColumnSegment) visit(ctx.bitExpr(0));
- PredicateBracketValue predicateBracketValue = createBracketValue(ctx);
+ private PredicateSegment createInSegment(final AExprContext ctx) {
+ ColumnSegment column = (ColumnSegment) visit(ctx.aExpr(0).cExpr().columnref());
+ PredicateBracketValue predicateBracketValue = createBracketValue(ctx.inExpr());
return new PredicateSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), column, new PredicateInRightValue(predicateBracketValue, getExpressionSegments(ctx)));
}
- private Collection<ExpressionSegment> getExpressionSegments(final PredicateContext ctx) {
+ private Collection<ExpressionSegment> getExpressionSegments(final AExprContext ctx) {
Collection<ExpressionSegment> result = new LinkedList<>();
- if (null != ctx.subquery()) {
- SubqueryContext subquery = ctx.subquery();
- result.add(new SubqueryExpressionSegment(new SubquerySegment(subquery.getStart().getStartIndex(), subquery.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()))));
- return result;
- }
- for (ExprContext each : ctx.expr()) {
- result.add((ExpressionSegment) visit(each));
- }
+// if (null != ctx.cExpr() && null != ctx.cExpr().select_with_parens()) {
+// Select_with_parensContext subquery = ctx.cExpr().select_with_parens();
+// result.add(new SubqueryExpressionSegment(new SubquerySegment(subquery.getStart().getStartIndex(), subquery.getStop().getStopIndex(),
+// (SelectStatement) visit(ctx.cExpr().select_with_parens()))));
+// return result;
+// }
+// for (AExprContext each : ctx.aExpr()) {
+// result.add(new CommonExpressionSegment(each.start.getStartIndex(), each.stop.getStopIndex(), each.getText()));
+// }
return result;
}
- private PredicateBracketValue createBracketValue(final PredicateContext ctx) {
- PredicateLeftBracketValue predicateLeftBracketValue = null != ctx.subquery()
- ? new PredicateLeftBracketValue(ctx.subquery().LP_().getSymbol().getStartIndex(), ctx.subquery().LP_().getSymbol().getStopIndex())
- : new PredicateLeftBracketValue(ctx.LP_().getSymbol().getStartIndex(), ctx.LP_().getSymbol().getStopIndex());
- PredicateRightBracketValue predicateRightBracketValue = null != ctx.subquery()
- ? new PredicateRightBracketValue(ctx.subquery().RP_().getSymbol().getStartIndex(), ctx.subquery().RP_().getSymbol().getStopIndex())
- : new PredicateRightBracketValue(ctx.RP_().getSymbol().getStartIndex(), ctx.RP_().getSymbol().getStopIndex());
+ private PredicateBracketValue createBracketValue(final InExprContext ctx) {
+ PredicateLeftBracketValue predicateLeftBracketValue = new PredicateLeftBracketValue(ctx.LP_().getSymbol().getStartIndex(), ctx.LP_().getSymbol().getStopIndex());
+ PredicateRightBracketValue predicateRightBracketValue = new PredicateRightBracketValue(ctx.RP_().getSymbol().getStartIndex(), ctx.RP_().getSymbol().getStopIndex());
+ visit(ctx);
return new PredicateBracketValue(predicateLeftBracketValue, predicateRightBracketValue);
}
- private PredicateSegment createBetweenSegment(final PredicateContext ctx) {
- ColumnSegment column = (ColumnSegment) visit(ctx.bitExpr(0));
- ExpressionSegment between = (ExpressionSegment) visit(ctx.bitExpr(1));
- ExpressionSegment and = (ExpressionSegment) visit(ctx.predicate());
- return new PredicateSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), column, new PredicateBetweenRightValue(between, and));
- }
-
- private ASTNode visitRemainPredicate(final PredicateContext ctx) {
- for (BitExprContext each : ctx.bitExpr()) {
- visit(each);
- }
- for (ExprContext each : ctx.expr()) {
- visit(each);
- }
- for (SimpleExprContext each : ctx.simpleExpr()) {
- visit(each);
- }
- if (null != ctx.predicate()) {
- visit(ctx.predicate());
- }
- return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+ private PredicateSegment createBetweenSegment(final AExprContext ctx) {
+ ColumnSegment column = (ColumnSegment) visit(ctx.aExpr().get(0));
+ return new PredicateSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), column, new PredicateBetweenRightValue((ExpressionSegment) visit(ctx.bExpr()),
+ (ExpressionSegment) visit(ctx.aExpr(1))));
}
@Override
- public final ASTNode visitBitExpr(final BitExprContext ctx) {
- if (null != ctx.simpleExpr()) {
- return createExpressionSegment(visit(ctx.simpleExpr()), ctx);
- }
- visitRemainBitExpr(ctx);
- return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
- }
-
- private ASTNode createExpressionSegment(final ASTNode astNode, final ParserRuleContext context) {
- if (astNode instanceof StringLiteralValue) {
- return new LiteralExpressionSegment(context.start.getStartIndex(), context.stop.getStopIndex(), ((StringLiteralValue) astNode).getValue());
- }
- if (astNode instanceof NumberLiteralValue) {
- return new LiteralExpressionSegment(context.start.getStartIndex(), context.stop.getStopIndex(), ((NumberLiteralValue) astNode).getValue());
- }
- if (astNode instanceof BooleanLiteralValue) {
- return new LiteralExpressionSegment(context.start.getStartIndex(), context.stop.getStopIndex(), ((BooleanLiteralValue) astNode).getValue());
- }
- if (astNode instanceof ParameterMarkerValue) {
- return new ParameterMarkerExpressionSegment(context.start.getStartIndex(), context.stop.getStopIndex(), ((ParameterMarkerValue) astNode).getValue());
+ public ASTNode visitBExpr(final BExprContext ctx) {
+ if (null != ctx.cExpr()) {
+ return visit(ctx.cExpr());
}
- if (astNode instanceof SubquerySegment) {
- return new SubqueryExpressionSegment((SubquerySegment) astNode);
- }
- if (astNode instanceof OtherLiteralValue) {
- return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), context.getText());
+ for (BExprContext each : ctx.bExpr()) {
+ visit(each);
}
- return astNode;
- }
-
- private void visitRemainBitExpr(final BitExprContext ctx) {
- ctx.bitExpr().forEach(this::visit);
+ return new LiteralExpressionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText());
}
- @Override
- public final ASTNode visitSimpleExpr(final SimpleExprContext ctx) {
- if (null != ctx.subquery()) {
- return new SubquerySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (SelectStatement) visit(ctx.subquery()));
- }
- if (null != ctx.parameterMarker()) {
- return visit(ctx.parameterMarker());
- }
- if (null != ctx.literals()) {
- return visit(ctx.literals());
+ protected ProjectionSegment generateProjectFromFuncExpr(final FuncExprContext ctx) {
+ if (null != ctx.funcApplication()) {
+ return generateProjectFromFuncApplication(ctx.funcApplication());
}
- if (null != ctx.functionCall()) {
- return visit(ctx.functionCall());
- }
- if (null != ctx.columnName()) {
- return visit(ctx.columnName());
- }
- return visitRemainSimpleExpr(ctx);
+
+ return generateProjectFromFunctionExprCommonSubexpr(ctx.functionExprCommonSubexpr());
}
- @Override
- public final ASTNode visitFunctionCall(final FunctionCallContext ctx) {
- if (null != ctx.aggregationFunction()) {
- return visit(ctx.aggregationFunction());
- }
- if (null != ctx.specialFunction()) {
- return visit(ctx.specialFunction());
+ private ProjectionSegment generateProjectFromFuncApplication(final FuncApplicationContext ctx) {
+ String aggregationType = ctx.funcName().getText();
+ if (AggregationType.isAggregationType(aggregationType)) {
+ return createAggregationSegment(ctx, aggregationType);
}
- if (null != ctx.regularFunction()) {
- return visit(ctx.regularFunction());
- }
- throw new IllegalStateException("FunctionCallContext must have aggregationFunction, regularFunction or specialFunction.");
+
+ return new ExpressionProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
}
- @Override
- public final ASTNode visitAggregationFunction(final AggregationFunctionContext ctx) {
- String aggregationType = ctx.aggregationFunctionName().getText();
- return AggregationType.isAggregationType(aggregationType)
- ? createAggregationSegment(ctx, aggregationType) : new ExpressionProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+ private ProjectionSegment generateProjectFromFunctionExprCommonSubexpr(final FunctionExprCommonSubexprContext ctx) {
+ return new ExpressionProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
}
- private ASTNode createAggregationSegment(final AggregationFunctionContext ctx, final String aggregationType) {
+ private ProjectionSegment createAggregationSegment(final FuncApplicationContext ctx, final String aggregationType) {
AggregationType type = AggregationType.valueOf(aggregationType.toUpperCase());
int innerExpressionStartIndex = ((TerminalNode) ctx.getChild(1)).getSymbol().getStartIndex();
- if (null == ctx.distinct()) {
+ if (null == ctx.DISTINCT()) {
return new AggregationProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), type, innerExpressionStartIndex);
}
return new AggregationDistinctProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), type, innerExpressionStartIndex, getDistinctExpression(ctx));
}
-
- private String getDistinctExpression(final AggregationFunctionContext ctx) {
+
+ private String getDistinctExpression(final FuncApplicationContext ctx) {
StringBuilder result = new StringBuilder();
- for (int i = 3; i < ctx.getChildCount() - 1; i++) {
- result.append(ctx.getChild(i).getText());
+ result.append(ctx.funcArgList().getText());
+ if (null != ctx.sortClause()) {
+ result.append(ctx.sortClause().getText());
}
return result.toString();
}
@Override
- public final ASTNode visitSpecialFunction(final SpecialFunctionContext ctx) {
- if (null != ctx.windowFunction()) {
- return visit(ctx.windowFunction());
- }
- if (null != ctx.castFunction()) {
- return visit(ctx.castFunction());
- }
- return new ExpressionProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
- }
-
- @Override
- public final ASTNode visitWindowFunction(final WindowFunctionContext ctx) {
- calculateParameterCount(ctx.expr());
- return new ExpressionProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
- }
-
- @Override
- public final ASTNode visitCastFunction(final CastFunctionContext ctx) {
- calculateParameterCount(Collections.singleton(ctx.expr()));
- return new ExpressionProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
- }
-
- @Override
- public final ASTNode visitCharFunction(final CharFunctionContext ctx) {
- calculateParameterCount(ctx.expr());
- return new ExpressionProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
- }
-
- @Override
- public final ASTNode visitRegularFunction(final RegularFunctionContext ctx) {
- calculateParameterCount(ctx.expr());
- return new ExpressionProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
- }
-
- private ASTNode visitRemainSimpleExpr(final SimpleExprContext ctx) {
- if (null != ctx.caseExpression()) {
- return visit(ctx.caseExpression());
- }
- for (ExprContext each : ctx.expr()) {
- visit(each);
- }
- for (SimpleExprContext each : ctx.simpleExpr()) {
- visit(each);
- }
- return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
- }
-
- @Override
- public final ASTNode visitCaseExpression(final CaseExpressionContext ctx) {
- return visit(ctx.simpleExpr());
- }
-
- @Override
public final ASTNode visitDataTypeName(final DataTypeNameContext ctx) {
IdentifierContext identifierContext = ctx.identifier();
if (null != identifierContext) {
@@ -512,38 +355,39 @@ public abstract class PostgreSQLVisitor extends PostgreSQLStatementBaseVisitor<A
return new KeywordValue(Joiner.on(" ").join(dataTypeNames));
}
- // TODO :FIXME, sql case id: insert_with_str_to_date
- private void calculateParameterCount(final Collection<ExprContext> exprContexts) {
- for (ExprContext each : exprContexts) {
- visit(each);
- }
- }
-
@Override
- public final ASTNode visitOrderByClause(final OrderByClauseContext ctx) {
+ public final ASTNode visitSortClause(final SortClauseContext ctx) {
Collection<OrderByItemSegment> items = new LinkedList<>();
- for (OrderByItemContext each : ctx.orderByItem()) {
+ for (SortbyContext each : ctx.sortbyList().sortby()) {
items.add((OrderByItemSegment) visit(each));
}
return new OrderBySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), items);
}
-
+
@Override
- public final ASTNode visitOrderByItem(final OrderByItemContext ctx) {
- OrderDirection orderDirection = null != ctx.DESC() ? OrderDirection.DESC : OrderDirection.ASC;
- if (null != ctx.columnName()) {
- ColumnSegment column = (ColumnSegment) visit(ctx.columnName());
+ public final ASTNode visitSortby(final SortbyContext ctx) {
+
+ OrderDirection orderDirection = null != ctx.ascDesc() ? generateOrderDirection(ctx.ascDesc()) : OrderDirection.ASC;
+ ASTNode astNode = visit(ctx.aExpr());
+ if (astNode instanceof ColumnSegment) {
+ ColumnSegment column = (ColumnSegment) astNode;
return new ColumnOrderByItemSegment(column, orderDirection);
}
- if (null != ctx.numberLiterals()) {
- return new IndexOrderByItemSegment(ctx.numberLiterals().getStart().getStartIndex(), ctx.numberLiterals().getStop().getStopIndex(),
- SQLUtil.getExactlyNumber(ctx.numberLiterals().getText(), 10).intValue(), orderDirection);
+ if (astNode instanceof LiteralExpressionSegment) {
+ LiteralExpressionSegment index = (LiteralExpressionSegment) astNode;
+ return new IndexOrderByItemSegment(index.getStartIndex(), index.getStopIndex(),
+ Integer.valueOf(index.getLiterals().toString()), orderDirection);
}
- return new ExpressionOrderByItemSegment(ctx.expr().getStart().getStartIndex(), ctx.expr().getStop().getStopIndex(), ctx.expr().getText(), orderDirection);
+ return new ExpressionOrderByItemSegment(ctx.aExpr().getStart().getStartIndex(), ctx.aExpr().getStop().getStopIndex(), ctx.aExpr().getText(), orderDirection);
+ }
+
+ private OrderDirection generateOrderDirection(final AscDescContext ctx) {
+ OrderDirection result = null != ctx.DESC() ? OrderDirection.DESC : OrderDirection.ASC;
+ return result;
}
@Override
- public final ASTNode visitDataType(final PostgreSQLStatementParser.DataTypeContext ctx) {
+ public final ASTNode visitDataType(final DataTypeContext ctx) {
DataTypeSegment dataTypeSegment = new DataTypeSegment();
dataTypeSegment.setDataTypeName(((KeywordValue) visit(ctx.dataTypeName())).getValue());
dataTypeSegment.setStartIndex(ctx.start.getStartIndex());
@@ -556,7 +400,7 @@ public abstract class PostgreSQLVisitor extends PostgreSQLStatementBaseVisitor<A
}
@Override
- public final ASTNode visitDataTypeLength(final PostgreSQLStatementParser.DataTypeLengthContext ctx) {
+ public final ASTNode visitDataTypeLength(final DataTypeLengthContext ctx) {
DataTypeLengthSegment dataTypeLengthSegment = new DataTypeLengthSegment();
dataTypeLengthSegment.setStartIndex(ctx.start.getStartIndex());
dataTypeLengthSegment.setStopIndex(ctx.stop.getStartIndex());
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/java/org/apache/shardingsphere/sql/parser/postgresql/visitor/impl/PostgreSQLDMLVisitor.java b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/java/org/apache/shardingsphere/sql/parser/postgresql/visitor/impl/PostgreSQLDMLVisitor.java
index 2f503cf..d14485f 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/java/org/apache/shardingsphere/sql/parser/postgresql/visitor/impl/PostgreSQLDMLVisitor.java
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-dialect/shardingsphere-sql-parser-postgresql/src/main/java/org/apache/shardingsphere/sql/parser/postgresql/visitor/impl/PostgreSQLDMLVisitor.java
@@ -17,45 +17,54 @@
package org.apache.shardingsphere.sql.parser.postgresql.visitor.impl;
+import org.antlr.v4.runtime.tree.ParseTree;
import org.apache.shardingsphere.sql.parser.api.ASTNode;
import org.apache.shardingsphere.sql.parser.api.visitor.statement.DMLVisitor;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColumnNameContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SubqueryContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AliasContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AssignmentContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AssignmentValueContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AssignmentValuesContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColumnNamesContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AExprContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AliasClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.AttrNameContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColIdContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ColumnrefContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DeleteContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.DuplicateSpecificationContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ExprContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ExprListContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.FromClauseContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.GroupByClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.GroupByItemContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.GroupClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InsertColumnItemContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InsertColumnListContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InsertContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InsertValuesClauseContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JoinSpecificationContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InsertRestContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.InsertTargetContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JoinQualContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.JoinedTableContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.LimitClauseContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.LimitOffsetContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.LimitRowCountContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.MultipleTableNamesContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.MultipleTablesClauseContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.OrderByItemContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ProjectionContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ProjectionsContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.QualifiedShorthandContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.NameListContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.QualifiedNameContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.RelationExprContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.RelationExprOptAliasContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectClauseNContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SetAssignmentsClauseContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SingleTableClauseContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableFactorContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableNameContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectLimitContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectLimitValueContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectNoParensContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectOffsetValueContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SelectWithParensContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SetClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SetClauseListContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SetTargetContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SetTargetListContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.SimpleSelectContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableReferenceContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TableReferencesContext;
-import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.UnionClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TargetElContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.TargetListContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.UpdateContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.ValuesClauseContext;
import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.WhereClauseContext;
+import org.apache.shardingsphere.sql.parser.autogen.PostgreSQLStatementParser.WhereOrCurrentClauseContext;
import org.apache.shardingsphere.sql.parser.postgresql.visitor.PostgreSQLVisitor;
+import org.apache.shardingsphere.sql.parser.sql.constant.OrderDirection;
+import org.apache.shardingsphere.sql.parser.sql.segment.SQLSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.JoinSpecificationSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.JoinedTableSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.TableFactorSegment;
@@ -68,8 +77,9 @@ import org.apache.shardingsphere.sql.parser.sql.segment.dml.column.InsertColumns
import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.ExpressionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.complex.CommonExpressionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.simple.LiteralExpressionSegment;
-import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.subquery.SubqueryExpressionSegment;
+import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.expr.subquery.SubquerySegment;
+import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.AggregationDistinctProjectionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.AggregationProjectionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.ColumnProjectionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.ExpressionProjectionSegment;
@@ -79,12 +89,16 @@ import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.ShorthandProjec
import org.apache.shardingsphere.sql.parser.sql.segment.dml.item.SubqueryProjectionSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.GroupBySegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.OrderBySegment;
+import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.ColumnOrderByItemSegment;
+import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.ExpressionOrderByItemSegment;
+import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.IndexOrderByItemSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.OrderByItemSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.pagination.limit.LimitSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.pagination.limit.LimitValueSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.pagination.limit.NumberLiteralLimitValueSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.pagination.limit.ParameterMarkerLimitValueSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.predicate.AndPredicate;
+import org.apache.shardingsphere.sql.parser.sql.segment.dml.predicate.LockSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.predicate.OrPredicateSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.predicate.PredicateSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.predicate.WhereSegment;
@@ -92,15 +106,13 @@ import org.apache.shardingsphere.sql.parser.sql.segment.generic.AliasSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.generic.OwnerSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.generic.table.SimpleTableSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.generic.table.SubqueryTableSegment;
+import org.apache.shardingsphere.sql.parser.sql.segment.generic.table.TableNameSegment;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.DeleteStatement;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.InsertStatement;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.UpdateStatement;
import org.apache.shardingsphere.sql.parser.sql.value.collection.CollectionValue;
import org.apache.shardingsphere.sql.parser.sql.value.identifier.IdentifierValue;
-import org.apache.shardingsphere.sql.parser.sql.value.literal.impl.BooleanLiteralValue;
-import org.apache.shardingsphere.sql.parser.sql.value.literal.impl.NumberLiteralValue;
-import org.apache.shardingsphere.sql.parser.sql.value.parametermarker.ParameterMarkerValue;
import java.util.Collection;
import java.util.Collections;
@@ -116,151 +128,247 @@ public final class PostgreSQLDMLVisitor extends PostgreSQLVisitor implements DML
public ASTNode visitInsert(final InsertContext ctx) {
// TODO :FIXME, since there is no segment for insertValuesClause, InsertStatement is created by sub rule.
// TODO :deal with insert select
- InsertStatement result = (InsertStatement) visit(ctx.insertValuesClause());
- result.setTable((SimpleTableSegment) visit(ctx.tableName()));
+ InsertStatement result = (InsertStatement) visit(ctx.insertRest());
+ result.setTable((SimpleTableSegment) visit(ctx.insertTarget()));
result.setParameterCount(getCurrentParameterIndex());
return result;
}
- @SuppressWarnings("unchecked")
@Override
- public ASTNode visitInsertValuesClause(final InsertValuesClauseContext ctx) {
+ public ASTNode visitInsertTarget(final InsertTargetContext ctx) {
+ QualifiedNameContext qualifiedName = ctx.qualifiedName();
+ OwnerSegment owner = null;
+ TableNameSegment tableName;
+ if (null != qualifiedName.indirection()) {
+ ColIdContext colId = ctx.colId();
+
+ owner = new OwnerSegment(colId.start.getStartIndex(), colId.stop.getStopIndex(), new IdentifierValue(colId.getText()));
+ AttrNameContext attrName = qualifiedName.indirection().indirectionEl().attrName();
+ tableName = new TableNameSegment(attrName.start.getStartIndex(), attrName.stop.getStopIndex(), new IdentifierValue(attrName.getText()));
+ } else {
+ tableName = new TableNameSegment(qualifiedName.colId().start.getStartIndex(), qualifiedName.colId().stop.getStopIndex(), new IdentifierValue(qualifiedName.colId().getText()));
+ }
+ SimpleTableSegment result = new SimpleTableSegment(tableName);
+ result.setOwner(owner);
+ if (null != ctx.AS()) {
+ ColIdContext colId = ctx.colId();
+ result.setAlias(new AliasSegment(colId.start.getStartIndex(), colId.stop.getStopIndex(), new IdentifierValue(colId.getText())));
+ }
+ return result;
+ }
+
+ @Override
+ public ASTNode visitInsertRest(final InsertRestContext ctx) {
InsertStatement result = new InsertStatement();
- if (null != ctx.columnNames()) {
- ColumnNamesContext columnNames = ctx.columnNames();
- CollectionValue<ColumnSegment> columnSegments = (CollectionValue<ColumnSegment>) visit(columnNames);
- result.setInsertColumns(new InsertColumnsSegment(columnNames.start.getStartIndex(), columnNames.stop.getStopIndex(), columnSegments.getValue()));
+ if (null != ctx.insertColumnList()) {
+ InsertColumnListContext insertColumns = ctx.insertColumnList();
+ CollectionValue<ColumnSegment> columns = (CollectionValue<ColumnSegment>) visit(insertColumns);
+ InsertColumnsSegment insertColumnsSegment = new InsertColumnsSegment(insertColumns.start.getStartIndex() - 1, insertColumns.stop.getStopIndex() + 1, columns.getValue());
+ result.setInsertColumns(insertColumnsSegment);
} else {
result.setInsertColumns(new InsertColumnsSegment(ctx.start.getStartIndex() - 1, ctx.start.getStartIndex() - 1, Collections.emptyList()));
}
- result.getValues().addAll(createInsertValuesSegments(ctx.assignmentValues()));
+ ValuesClauseContext valuesClause = ctx.select().selectNoParens().selectClauseN().simpleSelect().valuesClause();
+ Collection<InsertValuesSegment> insertValuesSegments = createInsertValuesSegments(valuesClause);
+ result.getValues().addAll(insertValuesSegments);
return result;
}
- private Collection<InsertValuesSegment> createInsertValuesSegments(final Collection<AssignmentValuesContext> assignmentValuesContexts) {
- Collection<InsertValuesSegment> result = new LinkedList<>();
- for (AssignmentValuesContext each : assignmentValuesContexts) {
- result.add((InsertValuesSegment) visit(each));
+ @Override
+ public ASTNode visitInsertColumnList(final InsertColumnListContext ctx) {
+ CollectionValue<ColumnSegment> result = new CollectionValue<>();
+ if (null != ctx.insertColumnList()) {
+ result.getValue().addAll(((CollectionValue<ColumnSegment>) visit(ctx.insertColumnList())).getValue());
}
+ result.getValue().add((ColumnSegment) visit(ctx.insertColumnItem()));
return result;
}
- @SuppressWarnings("unchecked")
@Override
- public ASTNode visitUpdate(final UpdateContext ctx) {
- UpdateStatement result = new UpdateStatement();
- CollectionValue<TableReferenceSegment> tableReferences = (CollectionValue<TableReferenceSegment>) visit(ctx.tableReferences());
- for (TableReferenceSegment each : tableReferences.getValue()) {
- result.getTables().addAll(each.getSimpleTableSegments());
+ public ASTNode visitInsertColumnItem(final InsertColumnItemContext ctx) {
+ if (null != ctx.optIndirection().indirectionEl()) {
+ ColumnSegment columnSegment = new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.optIndirection().stop.getStopIndex(),
+ new IdentifierValue(ctx.optIndirection().indirectionEl().attrName().getText()));
+ columnSegment.setOwner(new OwnerSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText())));
+ return columnSegment;
+
+ } else {
+ ColumnSegment columnSegment = new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+ return columnSegment;
}
- result.setSetAssignment((SetAssignmentSegment) visit(ctx.setAssignmentsClause()));
- if (null != ctx.whereClause()) {
- result.setWhere((WhereSegment) visit(ctx.whereClause()));
+ }
+
+ private Collection<InsertValuesSegment> createInsertValuesSegments(final ValuesClauseContext ctx) {
+ Collection<InsertValuesSegment> result = new LinkedList<>();
+ if (null != ctx.valuesClause()) {
+ Collection<InsertValuesSegment> expressions = createInsertValuesSegments(ctx.valuesClause());
+ result.addAll(expressions);
}
- result.setParameterCount(getCurrentParameterIndex());
+ Collection<ExpressionSegment> expressions = createInsertValuesSegments(ctx.exprList());
+ InsertValuesSegment insertValuesSegment = new InsertValuesSegment(ctx.exprList().start.getStartIndex(), ctx.exprList().stop.getStopIndex(), (List<ExpressionSegment>) expressions);
+ result.add(insertValuesSegment);
return result;
}
- @Override
- public ASTNode visitSetAssignmentsClause(final SetAssignmentsClauseContext ctx) {
- Collection<AssignmentSegment> assignments = new LinkedList<>();
- for (AssignmentContext each : ctx.assignment()) {
- assignments.add((AssignmentSegment) visit(each));
+ private Collection<ExpressionSegment> createInsertValuesSegments(final ExprListContext ctx) {
+ Collection<ExpressionSegment> result = new LinkedList<>();
+
+ if (null != ctx.exprList()) {
+ Collection<ExpressionSegment> tmpResult = createInsertValuesSegments(ctx.exprList());
+ result.addAll(tmpResult);
}
- return new SetAssignmentSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), assignments);
+ visit(ctx.aExpr());
+ CommonExpressionSegment expressionSegment = new CommonExpressionSegment(ctx.aExpr().start.getStartIndex(), ctx.aExpr().stop.getStopIndex(), ctx.aExpr().getText());
+ result.add(expressionSegment);
+ return result;
}
- @Override
- public ASTNode visitAssignmentValues(final AssignmentValuesContext ctx) {
- List<ExpressionSegment> segments = new LinkedList<>();
- for (AssignmentValueContext each : ctx.assignmentValue()) {
- segments.add((ExpressionSegment) visit(each));
+ private Collection<AssignmentSegment> generateAssignmentSegments(final SetClauseListContext ctx) {
+ Collection<AssignmentSegment> result = new LinkedList<>();
+ if (null != ctx.setClauseList()) {
+ Collection<AssignmentSegment> tmpResult = generateAssignmentSegments(ctx.setClauseList());
+ result.addAll(tmpResult);
}
- return new InsertValuesSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), segments);
+ AssignmentSegment assignmentSegment = (AssignmentSegment) visit(ctx.setClause());
+ result.add(assignmentSegment);
+ return result;
}
@Override
- public ASTNode visitAssignment(final AssignmentContext ctx) {
- ColumnSegment column = (ColumnSegment) visitColumnName(ctx.columnName());
- ExpressionSegment value = (ExpressionSegment) visit(ctx.assignmentValue());
- return new AssignmentSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), column, value);
+ public ASTNode visitSetClause(final SetClauseContext ctx) {
+ ColumnSegment columnSegment = (ColumnSegment) visit(ctx.setTarget());
+ SQLSegment sqlSegment = (SQLSegment) visit(ctx.aExpr());
+ ExpressionSegment expressionSegment = new CommonExpressionSegment(sqlSegment.getStartIndex(), sqlSegment.getStopIndex(), sqlSegment.toString());
+ AssignmentSegment result = new AssignmentSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), columnSegment, expressionSegment);
+ return result;
}
@Override
- public ASTNode visitAssignmentValue(final AssignmentValueContext ctx) {
- ExprContext expr = ctx.expr();
- if (null != expr) {
- return visit(expr);
+ public ASTNode visitSetTarget(final SetTargetContext ctx) {
+ OwnerSegment owner = null;
+ IdentifierValue identifierValue;
+ if (null != ctx.optIndirection().indirectionEl()) {
+ owner = new OwnerSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+ identifierValue = new IdentifierValue(ctx.optIndirection().getText());
+ } else {
+ identifierValue = new IdentifierValue(ctx.colId().getText());
}
- return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
+ ColumnSegment result = new ColumnSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), identifierValue);
+ result.setOwner(owner);
+ return result;
}
- @SuppressWarnings("unchecked")
@Override
- public ASTNode visitDelete(final DeleteContext ctx) {
- DeleteStatement result = new DeleteStatement();
- if (null != ctx.multipleTablesClause()) {
- result.getTables().addAll(((CollectionValue<SimpleTableSegment>) visit(ctx.multipleTablesClause())).getValue());
+ public ASTNode visitRelationExprOptAlias(final RelationExprOptAliasContext ctx) {
+ SimpleTableSegment result;
+ if (null != ctx.colId()) {
+ ColIdContext colId = ctx.relationExpr().qualifiedName().colId();
+ result = new SimpleTableSegment(colId.start.getStartIndex(), colId.stop.getStopIndex(), new IdentifierValue(colId.getText()));
+ result.setAlias(new AliasSegment(ctx.colId().start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(ctx.colId().getText())));
} else {
- result.getTables().add((SimpleTableSegment) visit(ctx.singleTableClause()));
+ ColIdContext colId = ctx.relationExpr().qualifiedName().colId();
+ result = new SimpleTableSegment(colId.start.getStartIndex(), colId.stop.getStopIndex(), new IdentifierValue(colId.getText()));
}
- if (null != ctx.whereClause()) {
- result.setWhere((WhereSegment) visit(ctx.whereClause()));
+ return result;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ public ASTNode visitUpdate(final UpdateContext ctx) {
+ UpdateStatement result = new UpdateStatement();
+ SimpleTableSegment tableSegment = (SimpleTableSegment) visit(ctx.relationExprOptAlias());
+ result.getTables().add(tableSegment);
+ result.setSetAssignment((SetAssignmentSegment) visit(ctx.setClauseList()));
+ if (null != ctx.whereOrCurrentClause()) {
+ result.setWhere((WhereSegment) visit(ctx.whereOrCurrentClause()));
}
result.setParameterCount(getCurrentParameterIndex());
return result;
}
@Override
- public ASTNode visitSingleTableClause(final SingleTableClauseContext ctx) {
- SimpleTableSegment result = (SimpleTableSegment) visit(ctx.tableName());
- if (null != ctx.alias()) {
- result.setAlias((AliasSegment) visit(ctx.alias()));
- }
+ public ASTNode visitSetClauseList(final SetClauseListContext ctx) {
+ Collection<AssignmentSegment> assignments = generateAssignmentSegments(ctx);
+ SetAssignmentSegment result = new SetAssignmentSegment(ctx.start.getStartIndex() - 4, ctx.stop.getStopIndex(), assignments);
return result;
}
+ @Override
+ public ASTNode visitSetTargetList(final SetTargetListContext ctx) {
+ return super.visitSetTargetList(ctx);
+ }
+
@SuppressWarnings("unchecked")
@Override
- public ASTNode visitMultipleTablesClause(final MultipleTablesClauseContext ctx) {
- CollectionValue<SimpleTableSegment> result = new CollectionValue<>();
- CollectionValue<TableReferenceSegment> tableReferences = (CollectionValue<TableReferenceSegment>) visit(ctx.tableReferences());
- for (TableReferenceSegment each : tableReferences.getValue()) {
- result.getValue().addAll(each.getSimpleTableSegments());
+ public ASTNode visitDelete(final DeleteContext ctx) {
+ DeleteStatement result = new DeleteStatement();
+ SimpleTableSegment tableSegment = (SimpleTableSegment) visit(ctx.relationExprOptAlias());
+ result.getTables().add(tableSegment);
+ if (null != ctx.whereOrCurrentClause()) {
+ result.setWhere((WhereSegment) visit(ctx.whereOrCurrentClause()));
}
+ result.setParameterCount(getCurrentParameterIndex());
return result;
}
@Override
- public ASTNode visitMultipleTableNames(final MultipleTableNamesContext ctx) {
- CollectionValue<SimpleTableSegment> result = new CollectionValue<>();
- for (TableNameContext each : ctx.tableName()) {
- result.getValue().add((SimpleTableSegment) visit(each));
- }
- return result;
+ public ASTNode visitWhereOrCurrentClause(final WhereOrCurrentClauseContext ctx) {
+ return visit(ctx.whereClause());
}
@Override
public ASTNode visitSelect(final SelectContext ctx) {
// TODO :Unsupported for withClause.
- SelectStatement result = (SelectStatement) visit(ctx.unionClause());
+ SelectStatement result = (SelectStatement) visit(ctx.selectNoParens());
result.setParameterCount(getCurrentParameterIndex());
return result;
}
@Override
- public ASTNode visitUnionClause(final UnionClauseContext ctx) {
- // TODO :Unsupported for union SQL.
- return visit(ctx.selectClause(0));
+ public ASTNode visitSelectNoParens(final SelectNoParensContext ctx) {
+ SelectStatement result = (SelectStatement) visit(ctx.selectClauseN());
+ if (null != ctx.sortClause()) {
+ OrderBySegment orderBySegment = (OrderBySegment) visit(ctx.sortClause());
+ result.setOrderBy(orderBySegment);
+ }
+ if (null != ctx.selectLimit()) {
+ LimitSegment limitSegment = (LimitSegment) visit(ctx.selectLimit());
+ result.setLimit(limitSegment);
+ }
+ if (null != ctx.forLockingClause()) {
+ LockSegment lockSegment = (LockSegment) visit(ctx.forLockingClause());
+ result.setLock(lockSegment);
+ }
+ return result;
+ }
+
+ @Override
+ public ASTNode visitSelectWithParens(final SelectWithParensContext ctx) {
+
+ if (null != ctx.selectWithParens()) {
+ return visit(ctx.selectWithParens());
+ }
+ return visit(ctx.selectNoParens());
+ }
+
+ @Override
+ public ASTNode visitSelectClauseN(final SelectClauseNContext ctx) {
+ if (null != ctx.simpleSelect()) {
+ SelectStatement result = (SelectStatement) visit(ctx.simpleSelect());
+ return result;
+ }
+ return new SelectStatement();
}
- @SuppressWarnings("unchecked")
@Override
- public ASTNode visitSelectClause(final SelectClauseContext ctx) {
+ public ASTNode visitSimpleSelect(final SimpleSelectContext ctx) {
SelectStatement result = new SelectStatement();
- result.setProjections((ProjectionsSegment) visit(ctx.projections()));
- if (null != ctx.duplicateSpecification()) {
- result.getProjections().setDistinctRow(isDistinct(ctx));
+ if (null != ctx.targetList()) {
+ ProjectionsSegment projects = (ProjectionsSegment) visit(ctx.targetList());
+ if (null != ctx.distinctClause()) {
+ projects.setDistinctRow(true);
+ }
+ result.setProjections(projects);
}
if (null != ctx.fromClause()) {
CollectionValue<TableReferenceSegment> tableReferences = (CollectionValue<TableReferenceSegment>) visit(ctx.fromClause());
@@ -271,200 +379,240 @@ public final class PostgreSQLDMLVisitor extends PostgreSQLVisitor implements DML
if (null != ctx.whereClause()) {
result.setWhere((WhereSegment) visit(ctx.whereClause()));
}
- if (null != ctx.groupByClause()) {
- result.setGroupBy((GroupBySegment) visit(ctx.groupByClause()));
- }
- if (null != ctx.orderByClause()) {
- result.setOrderBy((OrderBySegment) visit(ctx.orderByClause()));
- }
- if (null != ctx.limitClause()) {
- result.setLimit((LimitSegment) visit(ctx.limitClause()));
+ if (null != ctx.groupClause()) {
+ result.setGroupBy((GroupBySegment) visit(ctx.groupClause()));
}
return result;
}
- private boolean isDistinct(final SelectClauseContext ctx) {
- return ((BooleanLiteralValue) visit(ctx.duplicateSpecification())).getValue();
- }
-
- @Override
- public ASTNode visitDuplicateSpecification(final DuplicateSpecificationContext ctx) {
- return new BooleanLiteralValue(null != ctx.DISTINCT());
- }
-
@Override
- public ASTNode visitProjections(final ProjectionsContext ctx) {
- Collection<ProjectionSegment> projections = new LinkedList<>();
- if (null != ctx.unqualifiedShorthand()) {
- projections.add(new ShorthandProjectionSegment(ctx.unqualifiedShorthand().getStart().getStartIndex(), ctx.unqualifiedShorthand().getStop().getStopIndex()));
- }
- for (ProjectionContext each : ctx.projection()) {
- projections.add((ProjectionSegment) visit(each));
+ public ASTNode visitGroupClause(final GroupClauseContext ctx) {
+ Collection<OrderByItemSegment> items = new LinkedList<>();
+ for (GroupByItemContext each : ctx.groupByList().groupByItem()) {
+ items.add((OrderByItemSegment) visit(each));
}
- ProjectionsSegment result = new ProjectionsSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex());
- result.getProjections().addAll(projections);
+ GroupBySegment result = new GroupBySegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), items);
return result;
}
@Override
- public ASTNode visitProjection(final ProjectionContext ctx) {
- // FIXME :The stop index of project is the stop index of projection, instead of alias.
- if (null != ctx.qualifiedShorthand()) {
- QualifiedShorthandContext shorthand = ctx.qualifiedShorthand();
- ShorthandProjectionSegment result = new ShorthandProjectionSegment(shorthand.getStart().getStartIndex(), shorthand.getStop().getStopIndex());
- IdentifierValue identifier = new IdentifierValue(shorthand.identifier().getText());
- result.setOwner(new OwnerSegment(shorthand.identifier().getStart().getStartIndex(), shorthand.identifier().getStop().getStopIndex(), identifier));
- return result;
- }
- AliasSegment alias = null == ctx.alias() ? null : (AliasSegment) visit(ctx.alias());
- if (null != ctx.columnName()) {
- ColumnSegment column = (ColumnSegment) visit(ctx.columnName());
- ColumnProjectionSegment result = new ColumnProjectionSegment(column);
- result.setAlias(alias);
- return result;
+ public ASTNode visitGroupByItem(final GroupByItemContext ctx) {
+ if (null != ctx.aExpr()) {
+ ASTNode astNode = visit(ctx.aExpr());
+ if (astNode instanceof ColumnSegment) {
+ OrderByItemSegment result = new ColumnOrderByItemSegment((ColumnSegment) astNode, OrderDirection.ASC);
+ return result;
+ }
+ if (astNode instanceof LiteralExpressionSegment) {
+ LiteralExpressionSegment index = (LiteralExpressionSegment) astNode;
+ return new IndexOrderByItemSegment(index.getStartIndex(), index.getStopIndex(),
+ Integer.valueOf(index.getLiterals().toString()), OrderDirection.ASC);
+ }
+ return new ExpressionOrderByItemSegment(ctx.start.getStartIndex(), ctx.start.getStopIndex(), ctx.getText(), OrderDirection.ASC);
}
- return createProjection(ctx, alias);
+ return new ExpressionOrderByItemSegment(ctx.start.getStartIndex(), ctx.start.getStopIndex(), ctx.getText(), OrderDirection.ASC);
}
@Override
- public ASTNode visitAlias(final AliasContext ctx) {
- if (null != ctx.identifier()) {
- return new AliasSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (IdentifierValue) visit(ctx.identifier()));
- }
- return new AliasSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(ctx.STRING_().getText()));
+ public ASTNode visitTargetList(final TargetListContext ctx) {
+ ProjectionsSegment result = new ProjectionsSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex());
+ if (null != ctx.targetList()) {
+ ProjectionsSegment projecs = (ProjectionsSegment) visit(ctx.targetList());
+ result.getProjections().addAll(projecs.getProjections());
+ }
+ ProjectionSegment projection = (ProjectionSegment) visit(ctx.targetEl());
+ result.getProjections().add(projection);
+ return result;
}
- private ASTNode createProjection(final ProjectionContext ctx, final AliasSegment alias) {
- ASTNode projection = visit(ctx.expr());
- if (projection instanceof AggregationProjectionSegment) {
- ((AggregationProjectionSegment) projection).setAlias(alias);
+ @Override
+ public ASTNode visitTargetEl(final TargetElContext ctx) {
+ if (null != ctx.ASTERISK_()) {
+ return new ShorthandProjectionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex());
+ }
+ if (null != ctx.DOT_ASTERISK_()) {
+ ShorthandProjectionSegment shorthandProjection = new ShorthandProjectionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex());
+ shorthandProjection.setOwner(new OwnerSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText())));
+ return shorthandProjection;
+ }
+ AExprContext expr = ctx.aExpr();
+ if (null != expr.cExpr() && null != expr.cExpr().columnref()) {
+ ColumnProjectionSegment projection = generateColumnProjection(expr.cExpr().columnref());
+ AliasSegment alias = null != ctx.identifier()
+ ? new AliasSegment(ctx.identifier().start.getStartIndex(), ctx.identifier().stop.getStopIndex(), new IdentifierValue(ctx.identifier().getText())) : null;
+ projection.setAlias(alias);
return projection;
}
- if (projection instanceof ExpressionProjectionSegment) {
- ((ExpressionProjectionSegment) projection).setAlias(alias);
+ if (null != expr.cExpr() && null != expr.cExpr().funcExpr()) {
+ super.visit(expr.cExpr().funcExpr());
+ ProjectionSegment projection = generateProjectFromFuncExpr(expr.cExpr().funcExpr());
+ AliasSegment alias = null != ctx.identifier()
+ ? new AliasSegment(ctx.identifier().start.getStartIndex(), ctx.identifier().stop.getStopIndex(), new IdentifierValue(ctx.identifier().getText())) : null;
+ if (projection instanceof AggregationProjectionSegment) {
+ ((AggregationProjectionSegment) projection).setAlias(alias);
+ }
+ if (projection instanceof AggregationDistinctProjectionSegment) {
+ ((AggregationDistinctProjectionSegment) projection).setAlias(alias);
+ }
return projection;
}
- if (projection instanceof CommonExpressionSegment) {
- CommonExpressionSegment segment = (CommonExpressionSegment) projection;
- ExpressionProjectionSegment result = new ExpressionProjectionSegment(segment.getStartIndex(), segment.getStopIndex(), segment.getText());
- result.setAlias(alias);
- return result;
+
+ if (null != expr.cExpr() && null != expr.cExpr().selectWithParens()) {
+ SelectStatement select = (SelectStatement) visit(expr.cExpr().selectWithParens());
+ SubquerySegment subquery = new SubquerySegment(expr.cExpr().selectWithParens().start.getStartIndex(), expr.cExpr().selectWithParens().stop.getStopIndex(), select);
+ SubqueryProjectionSegment projection = new SubqueryProjectionSegment(subquery);
+ AliasSegment alias = null != ctx.identifier()
+ ? new AliasSegment(ctx.identifier().start.getStartIndex(), ctx.identifier().stop.getStopIndex(), new IdentifierValue(ctx.identifier().getText())) : null;
+ projection.setAlias(alias);
+ return projection;
}
- // FIXME :For DISTINCT()
- if (projection instanceof ColumnSegment) {
- ExpressionProjectionSegment result = new ExpressionProjectionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText());
- result.setAlias(alias);
- return result;
+
+ ExpressionProjectionSegment projection = new ExpressionProjectionSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), expr.getText());
+ if (null != ctx.identifier()) {
+ AliasSegment alias = new AliasSegment(ctx.identifier().start.getStartIndex(), ctx.identifier().stop.getStopIndex(), new IdentifierValue(ctx.identifier().getText()));
+ projection.setAlias(alias);
}
- if (projection instanceof SubqueryExpressionSegment) {
- SubqueryProjectionSegment result = new SubqueryProjectionSegment(((SubqueryExpressionSegment) projection).getSubquery());
- result.setAlias(alias);
- return result;
+ return projection;
+ }
+
+ private ColumnProjectionSegment generateColumnProjection(final ColumnrefContext ctx) {
+ if (null != ctx.indirection()) {
+ PostgreSQLStatementParser.AttrNameContext attrName = ctx.indirection().indirectionEl().attrName();
+ ColumnSegment columnSegment = new ColumnSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(attrName.getText()));
+ OwnerSegment owner = new OwnerSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+ columnSegment.setOwner(owner);
+ ColumnProjectionSegment columnProjection = new ColumnProjectionSegment(columnSegment);
+ return columnProjection;
}
- LiteralExpressionSegment column = (LiteralExpressionSegment) projection;
- ExpressionProjectionSegment result = null == alias ? new ExpressionProjectionSegment(column.getStartIndex(), column.getStopIndex(), String.valueOf(column.getLiterals()))
- : new ExpressionProjectionSegment(column.getStartIndex(), ctx.alias().stop.getStopIndex(), String.valueOf(column.getLiterals()));
- result.setAlias(alias);
- return result;
+ ColumnSegment columnSegment = new ColumnSegment(ctx.colId().start.getStartIndex(), ctx.colId().stop.getStopIndex(), new IdentifierValue(ctx.colId().getText()));
+ ColumnProjectionSegment columnProjection = new ColumnProjectionSegment(columnSegment);
+ return columnProjection;
}
@Override
public ASTNode visitFromClause(final FromClauseContext ctx) {
- return visit(ctx.tableReferences());
+ return visit(ctx.fromList());
}
- @SuppressWarnings("unchecked")
@Override
- public ASTNode visitTableReferences(final TableReferencesContext ctx) {
+ public ASTNode visitFromList(final PostgreSQLStatementParser.FromListContext ctx) {
CollectionValue<TableReferenceSegment> result = new CollectionValue<>();
- for (TableReferenceContext each : ctx.tableReference()) {
- result.getValue().add((TableReferenceSegment) visit(each));
+ if (null != ctx.fromList()) {
+ result.getValue().addAll(((CollectionValue<TableReferenceSegment>) visit(ctx.fromList())).getValue());
}
+ result.getValue().add((TableReferenceSegment) visit(ctx.tableReference()));
return result;
}
@Override
public ASTNode visitTableReference(final TableReferenceContext ctx) {
- TableReferenceSegment result = new TableReferenceSegment();
- if (null != ctx.tableFactor()) {
- TableFactorSegment tableFactor = (TableFactorSegment) visit(ctx.tableFactor());
- result.setTableFactor(tableFactor);
- }
- if (!ctx.joinedTable().isEmpty()) {
- for (JoinedTableContext each : ctx.joinedTable()) {
- JoinedTableSegment joinedTableSegment = (JoinedTableSegment) visit(each);
- result.getJoinedTables().add(joinedTableSegment);
- }
- }
- return result;
- }
- @Override
- public ASTNode visitTableFactor(final TableFactorContext ctx) {
- TableFactorSegment result = new TableFactorSegment();
- if (null != ctx.subquery()) {
- SelectStatement subquery = (SelectStatement) visit(ctx.subquery());
- SubquerySegment subquerySegment = new SubquerySegment(ctx.subquery().start.getStartIndex(), ctx.subquery().stop.getStopIndex(), subquery);
- SubqueryTableSegment subqueryTableSegment = new SubqueryTableSegment(subquerySegment);
- if (null != ctx.alias()) {
- subqueryTableSegment.setAlias((AliasSegment) visit(ctx.alias()));
+ if (null != ctx.tableReference()) {
+
+ TableReferenceSegment result = (TableReferenceSegment) visit(ctx.tableReference());
+ if (null != ctx.joinedTable()) {
+ result.getJoinedTables().add((JoinedTableSegment) visit(ctx.joinedTable()));
}
- result.setTable(subqueryTableSegment);
+ return result;
}
- if (null != ctx.tableName()) {
- SimpleTableSegment table = (SimpleTableSegment) visit(ctx.tableName());
- if (null != ctx.alias()) {
- table.setAlias((AliasSegment) visit(ctx.alias()));
+ if (null != ctx.relationExpr()) {
+ TableReferenceSegment result = new TableReferenceSegment();
+ SimpleTableSegment table = generateTableFromRelationExpr(ctx.relationExpr());
+ if (null != ctx.aliasClause()) {
+ table.setAlias((AliasSegment) visit(ctx.aliasClause()));
}
- result.setTable(table);
+ TableFactorSegment tableFactorSegment = new TableFactorSegment();
+ tableFactorSegment.setTable(table);
+ result.setTableFactor(tableFactorSegment);
+ return result;
}
- if (null != ctx.tableReferences()) {
- CollectionValue<TableReferenceSegment> tableReferences = (CollectionValue) visit(ctx.tableReferences());
- result.getTableReferences().addAll(tableReferences.getValue());
+ if (null != ctx.selectWithParens()) {
+ TableReferenceSegment result = new TableReferenceSegment();
+ SelectStatement select = (SelectStatement) visit(ctx.selectWithParens());
+ SubquerySegment subquery = new SubquerySegment(ctx.selectWithParens().start.getStartIndex(), ctx.selectWithParens().stop.getStopIndex(), select);
+ AliasSegment alias = null != ctx.aliasClause() ? (AliasSegment) visit(ctx.aliasClause()) : null;
+ SubqueryTableSegment subqueryTable = new SubqueryTableSegment(subquery);
+ subqueryTable.setAlias(alias);
+ TableFactorSegment tableFactor = new TableFactorSegment();
+ tableFactor.setTable(subqueryTable);
+ result.setTableFactor(tableFactor);
+ return result;
}
- return result;
+// TODO deal with functionTable and xmlTable
+ return new TableReferenceSegment();
}
- @SuppressWarnings("unchecked")
@Override
public ASTNode visitJoinedTable(final JoinedTableContext ctx) {
JoinedTableSegment result = new JoinedTableSegment();
- TableFactorSegment tableFactor = (TableFactorSegment) visit(ctx.tableFactor());
- result.setTableFactor(tableFactor);
- if (null != ctx.joinSpecification()) {
- result.setJoinSpecification((JoinSpecificationSegment) visit(ctx.joinSpecification()));
+ result.setTableFactor(((TableReferenceSegment) visit(ctx.tableReference())).getTableFactor());
+ if (null != ctx.joinQual()) {
+ JoinSpecificationSegment joinSpecification = (JoinSpecificationSegment) visit(ctx.joinQual());
+ result.setJoinSpecification(joinSpecification);
}
return result;
}
@Override
- public ASTNode visitJoinSpecification(final JoinSpecificationContext ctx) {
+ public ASTNode visitJoinQual(final JoinQualContext ctx) {
JoinSpecificationSegment result = new JoinSpecificationSegment();
- if (null != ctx.expr()) {
- ASTNode expr = visit(ctx.expr());
- if (expr instanceof PredicateSegment) {
+ if (null != ctx.ON()) {
+ ASTNode segment = visit(ctx.aExpr());
+ if (segment instanceof OrPredicateSegment) {
+ result.getAndPredicates().addAll(((OrPredicateSegment) segment).getAndPredicates());
+ } else if (segment instanceof PredicateSegment) {
AndPredicate andPredicate = new AndPredicate();
- andPredicate.getPredicates().add((PredicateSegment) expr);
+ andPredicate.getPredicates().add((PredicateSegment) segment);
result.getAndPredicates().add(andPredicate);
}
- if (expr instanceof OrPredicateSegment) {
- result.getAndPredicates().addAll(((OrPredicateSegment) expr).getAndPredicates());
- }
}
if (null != ctx.USING()) {
- Collection<ColumnSegment> columnSegmentList = new LinkedList<>();
- for (ColumnNameContext each : ctx.columnNames().columnName()) {
- columnSegmentList.add((ColumnSegment) visit(each));
- }
- result.getUsingColumns().addAll(columnSegmentList);
+ result.getUsingColumns().addAll(generateUsingColumn(ctx.nameList()));
+ }
+ return result;
+ }
+
+ private Collection<ColumnSegment> generateUsingColumn(final NameListContext ctx) {
+ Collection<ColumnSegment> result = new LinkedList<>();
+ if (null != ctx.nameList()) {
+ result.addAll(generateUsingColumn(ctx.nameList()));
+ }
+ if (null != ctx.name()) {
+ ColumnSegment column = new ColumnSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), new IdentifierValue(ctx.name().getText()));
+ result.add(column);
}
return result;
}
@Override
+ public ASTNode visitAliasClause(final AliasClauseContext ctx) {
+ StringBuilder aliasName = new StringBuilder(ctx.colId().getText());
+
+ if (null != ctx.nameList()) {
+ aliasName.append(ctx.LP_().getText());
+ aliasName.append(ctx.nameList().getText());
+ aliasName.append(ctx.RP_().getText());
+ }
+ AliasSegment alias = new AliasSegment(ctx.colId().start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(aliasName.toString()));
+ return alias;
+ }
+
+ private SimpleTableSegment generateTableFromRelationExpr(final RelationExprContext ctx) {
+ QualifiedNameContext qualifiedName = ctx.qualifiedName();
+
+ if (null != qualifiedName.indirection()) {
+ AttrNameContext tableName = qualifiedName.indirection().indirectionEl().attrName();
+ SimpleTableSegment table = new SimpleTableSegment(tableName.start.getStartIndex(), tableName.stop.getStopIndex(), new IdentifierValue(tableName.getText()));
+ table.setOwner(new OwnerSegment(qualifiedName.colId().start.getStartIndex(), qualifiedName.colId().stop.getStopIndex(), new IdentifierValue(qualifiedName.colId().getText())));
+ return table;
+ }
+ return new SimpleTableSegment(qualifiedName.colId().start.getStartIndex(), qualifiedName.colId().stop.getStopIndex(), new IdentifierValue(qualifiedName.colId().getText()));
+ }
+
+ @Override
public ASTNode visitWhereClause(final WhereClauseContext ctx) {
WhereSegment result = new WhereSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex());
- ASTNode segment = visit(ctx.expr());
+ ASTNode segment = visit(ctx.aExpr());
if (segment instanceof OrPredicateSegment) {
result.getAndPredicates().addAll(((OrPredicateSegment) segment).getAndPredicates());
} else if (segment instanceof PredicateSegment) {
@@ -476,63 +624,68 @@ public final class PostgreSQLDMLVisitor extends PostgreSQLVisitor implements DML
}
@Override
- public ASTNode visitGroupByClause(final GroupByClauseContext ctx) {
- Collection<OrderByItemSegment> items = new LinkedList<>();
- for (OrderByItemContext each : ctx.orderByItem()) {
- items.add((OrderByItemSegment) visit(each));
+ public ASTNode visitSelectLimit(final SelectLimitContext ctx) {
+ if (null != ctx.limitClause() && null != ctx.offsetClause()) {
+ return createLimitSegmentWhenLimitAndOffset(ctx);
}
- return new GroupBySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), items);
+ return createLimitSegmentWhenRowCountOrOffsetAbsent(ctx);
}
@Override
- public ASTNode visitLimitClause(final LimitClauseContext ctx) {
- if (null != ctx.limitRowCountSyntax() && null != ctx.limitOffsetSyntax()) {
- return isRowCountBeforeOffset(ctx) ? createLimitSegmentWhenRowCountBeforeOffset(ctx) : createLimitSegmentWhenRowCountAfterOffset(ctx);
+ public ASTNode visitSelectLimitValue(final SelectLimitValueContext ctx) {
+ if (null != ctx.ALL()) {
+ return null;
}
- return createLimitSegmentWhenRowCountOrOffsetAbsent(ctx);
- }
-
- private boolean isRowCountBeforeOffset(final LimitClauseContext ctx) {
- return ctx.limitRowCountSyntax().getStart().getStartIndex() < ctx.limitOffsetSyntax().getStart().getStartIndex();
- }
-
- private LimitSegment createLimitSegmentWhenRowCountBeforeOffset(final LimitClauseContext ctx) {
- LimitValueSegment rowCount = null == ctx.limitRowCountSyntax().limitRowCount() ? null : (LimitValueSegment) visit(ctx.limitRowCountSyntax().limitRowCount());
- LimitValueSegment offset = (LimitValueSegment) visit(ctx.limitOffsetSyntax().limitOffset());
- return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), offset, rowCount);
- }
-
- private LimitSegment createLimitSegmentWhenRowCountAfterOffset(final LimitClauseContext ctx) {
- LimitValueSegment offset = (LimitValueSegment) visit(ctx.limitOffsetSyntax().limitOffset());
- LimitValueSegment rowCount = null == ctx.limitRowCountSyntax().limitRowCount() ? null : (LimitValueSegment) visit(ctx.limitRowCountSyntax().limitRowCount());
- return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), offset, rowCount);
- }
-
- private LimitSegment createLimitSegmentWhenRowCountOrOffsetAbsent(final LimitClauseContext ctx) {
- LimitValueSegment rowCount = null == ctx.limitRowCountSyntax() || null == ctx.limitRowCountSyntax().limitRowCount()
- ? null : (LimitValueSegment) visit(ctx.limitRowCountSyntax().limitRowCount());
- LimitValueSegment offset = null == ctx.limitOffsetSyntax() ? null : (LimitValueSegment) visit(ctx.limitOffsetSyntax().limitOffset());
- return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), offset, rowCount);
+ ASTNode astNode = visit(ctx.aExpr());
+ if (astNode instanceof ParameterMarkerExpressionSegment) {
+ return new ParameterMarkerLimitValueSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ((ParameterMarkerExpressionSegment) astNode).getParameterMarkerIndex());
+ }
+ LimitValueSegment result = new NumberLiteralLimitValueSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(),
+ Long.valueOf(((LiteralExpressionSegment) astNode).getLiterals().toString()));
+ return result;
}
@Override
- public ASTNode visitLimitRowCount(final LimitRowCountContext ctx) {
- if (null != ctx.numberLiterals()) {
- return new NumberLiteralLimitValueSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ((NumberLiteralValue) visit(ctx.numberLiterals())).getValue().longValue());
+ public ASTNode visitSelectOffsetValue(final SelectOffsetValueContext ctx) {
+ ASTNode astNode = visit(ctx.aExpr());
+ if (astNode instanceof ParameterMarkerExpressionSegment) {
+ return new ParameterMarkerLimitValueSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ((ParameterMarkerExpressionSegment) astNode).getParameterMarkerIndex());
}
- return new ParameterMarkerLimitValueSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ((ParameterMarkerValue) visit(ctx.parameterMarker())).getValue());
+ LimitValueSegment result = new NumberLiteralLimitValueSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(),
+ Long.valueOf(((LiteralExpressionSegment) astNode).getLiterals().toString()));
+ return result;
}
- @Override
- public ASTNode visitLimitOffset(final LimitOffsetContext ctx) {
- if (null != ctx.numberLiterals()) {
- return new NumberLiteralLimitValueSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ((NumberLiteralValue) visit(ctx.numberLiterals())).getValue().longValue());
+ private LimitSegment createLimitSegmentWhenLimitAndOffset(final SelectLimitContext ctx) {
+ ParseTree astNode0 = ctx.getChild(0);
+ LimitValueSegment rowCount = null;
+ LimitValueSegment offset = null;
+ if (astNode0 instanceof LimitClauseContext) {
+ rowCount = null == ctx.limitClause().selectLimitValue() ? null : (LimitValueSegment) visit(ctx.limitClause().selectLimitValue());
+ } else {
+ offset = (LimitValueSegment) visit(ctx.offsetClause().selectOffsetValue());
+ }
+ ParseTree astNode1 = ctx.getChild(1);
+ if (astNode1 instanceof LimitClauseContext) {
+ rowCount = null == ctx.limitClause().selectLimitValue() ? null : (LimitValueSegment) visit(ctx.limitClause().selectLimitValue());
+ } else {
+ offset = (LimitValueSegment) visit(ctx.offsetClause().selectOffsetValue());
}
- return new ParameterMarkerLimitValueSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ((ParameterMarkerValue) visit(ctx.parameterMarker())).getValue());
+ return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), offset, rowCount);
}
+
+ private LimitSegment createLimitSegmentWhenRowCountOrOffsetAbsent(final SelectLimitContext ctx) {
+ if (null != ctx.limitClause()) {
+ if (null != ctx.limitClause().selectOffsetValue()) {
+ LimitValueSegment limit = (LimitValueSegment) visit(ctx.limitClause().selectLimitValue());
+ LimitValueSegment offset = (LimitValueSegment) visit(ctx.limitClause().selectOffsetValue());
+ return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), offset, limit);
+ }
+ LimitValueSegment limit = (LimitValueSegment) visit(ctx.limitClause().selectLimitValue());
+ return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), null, limit);
+ }
+ LimitValueSegment offset = (LimitValueSegment) visit(ctx.offsetClause().selectOffsetValue());
- @Override
- public ASTNode visitSubquery(final SubqueryContext ctx) {
- return visit(ctx.unionClause());
+ return new LimitSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), offset, null);
}
}
diff --git a/shardingsphere-sql-parser/shardingsphere-sql-parser-test/src/test/resources/case/dml/select.xml b/shardingsphere-sql-parser/shardingsphere-sql-parser-test/src/test/resources/case/dml/select.xml
index c55daa0..5df57c9 100644
--- a/shardingsphere-sql-parser/shardingsphere-sql-parser-test/src/test/resources/case/dml/select.xml
+++ b/shardingsphere-sql-parser/shardingsphere-sql-parser-test/src/test/resources/case/dml/select.xml
@@ -1097,12 +1097,17 @@
<operator type="=" />
<compare-right-value>
<parameter-marker-expression value="0" start-index="35" stop-index="42" />
- <literal-expression value="{"rule2":"null2"}'::json" start-index="35" stop-index="60" />
+ <literal-expression value="'{"rule2":"null2"}'::jsonb" start-index="35" stop-index="60" />
+ <common-expression literal-text="'{"rule2":"null2"}'::jsonb" start-index="35" stop-index="60" />
</compare-right-value>
</predicate>
<predicate start-index="48" stop-index="115" literal-start-index="66" literal-stop-index="137">
<column-left-value name="start_point" start-index="48" stop-index="58" literal-start-index="66" literal-stop-index="76" />
<operator type="=" />
+ <compare-right-value>
+ <common-expression literal-start-index="78" literal-stop-index="137" start-index="60" stop-index="115" literal-text="ST_GeographyFromText('SRID=4326;POINT('||100||' '||200||')')" text="ST_GeographyFromText('SRID=4326;POINT('||?||' '||?||')')"/>
+ <literal-expression start-index="78" stop-index="137" literal-text="ST_GeographyFromText('SRID=4326;POINT('||100||' '||200||')')"/>
+ </compare-right-value>
<!-- TODO assert expression -->
</predicate>
<predicate start-index="121" stop-index="131" literal-start-index="143" literal-stop-index="153">
@@ -1148,6 +1153,9 @@
<predicate start-index="61" stop-index="128" literal-start-index="97" literal-stop-index="168">
<column-left-value name="start_point" start-index="61" stop-index="71" literal-start-index="97" literal-stop-index="107" />
<operator type="=" />
+ <compare-right-value>
+ <common-expression literal-start-index="109" literal-stop-index="168" start-index="73" stop-index="128" literal-text="ST_GeographyFromText('SRID=4326;POINT('||100||' '||200||')')" text="ST_GeographyFromText('SRID=4326;POINT('||?||' '||?||')')"/>
+ </compare-right-value>
<!-- TODO assert expr -->
</predicate>
<predicate start-index="134" stop-index="144" literal-start-index="174" literal-stop-index="184">
@@ -1185,15 +1193,20 @@
<column-left-value name="rule" start-index="28" stop-index="31" />
<between-right-value>
<between-parameter-marker-expression value="0" start-index="41" stop-index="48" literal-start-index="48" literal-stop-index="55" />
- <between-literal-expression value="{"rule2":"null2"}'::json" start-index="41" stop-index="66" />
+ <between-literal-expression value="'{"rule2":"null2"}'::jsonb" start-index="41" stop-index="66" />
+ <between-common-expression value="'{"rule2":"null2"}'::jsonb" start-index="41" stop-index="66" />
<and-parameter-marker-expression value="1" start-index="54" stop-index="61" />
- <and-literal-expression value="{"rule3":"null3"}'::json" start-index="72" stop-index="97" />
+ <and-literal-expression value="'{"rule3":"null3"}'::jsonb" start-index="72" stop-index="97" />
+ <and-common-expression literal-text="'{"rule3":"null3"}'::jsonb" start-index="72" stop-index="97" />
</between-right-value>
</predicate>
<predicate start-index="67" stop-index="134" literal-start-index="103" literal-stop-index="174">
<column-left-value name="start_point" start-index="67" stop-index="77" literal-start-index="103" literal-stop-index="113" />
<operator type="=" />
<!-- TODO assert right value -->
+ <compare-right-value>
+ <common-expression literal-start-index="115" literal-stop-index="174" start-index="79" stop-index="134" literal-text="ST_GeographyFromText('SRID=4326;POINT('||100||' '||200||')')" text="ST_GeographyFromText('SRID=4326;POINT('||?||' '||?||')')"/>
+ </compare-right-value>
</predicate>
<predicate start-index="140" stop-index="151" literal-start-index="180" literal-stop-index="191">
<column-left-value name="order_id" start-index="140" stop-index="147" literal-start-index="180" literal-stop-index="187" />