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="{&quot;rule2&quot;:&quot;null2&quot;}'::json" start-index="35" stop-index="60" />
+                        <literal-expression value="'{&quot;rule2&quot;:&quot;null2&quot;}'::jsonb" start-index="35" stop-index="60" />
+                        <common-expression literal-text="'{&quot;rule2&quot;:&quot;null2&quot;}'::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="{&quot;rule2&quot;:&quot;null2&quot;}'::json" start-index="41" stop-index="66" />
+                        <between-literal-expression value="'{&quot;rule2&quot;:&quot;null2&quot;}'::jsonb" start-index="41" stop-index="66" />
+                        <between-common-expression value="'{&quot;rule2&quot;:&quot;null2&quot;}'::jsonb" start-index="41" stop-index="66" />
                         <and-parameter-marker-expression value="1" start-index="54" stop-index="61" />
-                        <and-literal-expression value="{&quot;rule3&quot;:&quot;null3&quot;}'::json" start-index="72" stop-index="97" />
+                        <and-literal-expression value="'{&quot;rule3&quot;:&quot;null3&quot;}'::jsonb" start-index="72" stop-index="97" />
+                        <and-common-expression literal-text="'{&quot;rule3&quot;:&quot;null3&quot;}'::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" />