bug fixed for oracle sql parser

src/main/java/com/alibaba/druid/sql/ast/expr/SQLUnaryOperator.java

@@ -16,7 +16,7 @@
 package com.alibaba.druid.sql.ast.expr;
 
 public enum SQLUnaryOperator {
-    Plus("+"), Negative("-"), Not("!"), Compl("~"), Prior("PRIOR"), ConnectByRoot("CONNECT BY");
+    Plus("+"), Negative("-"), Not("!"), Compl("~"), Prior("PRIOR"), ConnectByRoot("CONNECT BY"), NOT("NOT");
 
     public final String name;
 

src/main/java/com/alibaba/druid/sql/ast/statement/SQLAssignItem.java

@@ -0,0 +1,53 @@
+package com.alibaba.druid.sql.ast.statement;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.SQLObjectImpl;
+import com.alibaba.druid.sql.visitor.SQLASTVisitor;
+
+public class SQLAssignItem extends SQLObjectImpl {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLExpr           target;
+    private SQLExpr           value;
+
+    public SQLAssignItem(){
+    }
+
+    public SQLAssignItem(SQLExpr target, SQLExpr value){
+        this.target = target;
+        this.value = value;
+    }
+
+    public SQLExpr getTarget() {
+        return target;
+    }
+
+    public void setTarget(SQLExpr target) {
+        this.target = target;
+    }
+
+    public SQLExpr getValue() {
+        return value;
+    }
+
+    public void setValue(SQLExpr value) {
+        this.value = value;
+    }
+
+    public void output(StringBuffer buf) {
+        target.output(buf);
+        buf.append(" = ");
+        value.output(buf);
+    }
+
+    @Override
+    protected void accept0(SQLASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, this.target);
+            acceptChild(visitor, this.value);
+        }
+        visitor.endVisit(this);
+    }
+
+}

src/main/java/com/alibaba/druid/sql/ast/statement/SQLSetStatement.java

@@ -19,7 +19,6 @@ import java.util.ArrayList;
 import java.util.List;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
-import com.alibaba.druid.sql.ast.SQLObjectImpl;
 import com.alibaba.druid.sql.ast.SQLStatementImpl;
 import com.alibaba.druid.sql.visitor.SQLASTVisitor;
 
@@ -27,20 +26,20 @@ public class SQLSetStatement extends SQLStatementImpl {
 
     private static final long serialVersionUID = 1L;
 
-    private List<Item>        items            = new ArrayList<Item>();
+    private List<SQLAssignItem>        items            = new ArrayList<SQLAssignItem>();
 
     public SQLSetStatement(){
     }
     
     public SQLSetStatement(SQLExpr target, SQLExpr value) {
-        this.items.add(new Item(target, value));
+        this.items.add(new SQLAssignItem(target, value));
     }
 
-    public List<Item> getItems() {
+    public List<SQLAssignItem> getItems() {
         return items;
     }
 
-    public void setItems(List<Item> items) {
+    public void setItems(List<SQLAssignItem> items) {
         this.items = items;
     }
 
@@ -60,56 +59,8 @@ public class SQLSetStatement extends SQLStatementImpl {
                 buf.append(", ");
             }
 
-            Item item = items.get(i);
+            SQLAssignItem item = items.get(i);
             item.output(buf);
         }
     }
-
-    public static class Item extends SQLObjectImpl {
-
-        private static final long serialVersionUID = 1L;
-
-        private SQLExpr           target;
-        private SQLExpr           value;
-
-        public Item(){
-        }
-
-        public Item(SQLExpr target, SQLExpr value){
-            this.target = target;
-            this.value = value;
-        }
-
-        public SQLExpr getTarget() {
-            return target;
-        }
-
-        public void setTarget(SQLExpr target) {
-            this.target = target;
-        }
-
-        public SQLExpr getValue() {
-            return value;
-        }
-
-        public void setValue(SQLExpr value) {
-            this.value = value;
-        }
-
-        public void output(StringBuffer buf) {
-            target.output(buf);
-            buf.append(" = ");
-            value.output(buf);
-        }
-
-        @Override
-        protected void accept0(SQLASTVisitor visitor) {
-            if (visitor.visit(this)) {
-                acceptChild(visitor, this.target);
-                acceptChild(visitor, this.value);
-            }
-            visitor.endVisit(this);
-        }
-
-    }
 }

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/expr/OracleAggregateExpr.java

@@ -74,7 +74,16 @@ public class OracleAggregateExpr extends SQLAggregateExpr implements Serializabl
 
     @Override
     protected void accept0(SQLASTVisitor visitor) {
-        this.accept0((OracleASTVisitor) visitor);
+        if (visitor instanceof OracleASTVisitor) {
+            this.accept0((OracleASTVisitor) visitor);
+        } else {
+            if (visitor.visit(this)) {
+                acceptChild(visitor, this.methodName);
+                acceptChild(visitor, this.arguments);
+                acceptChild(visitor, this.over);
+            }
+            visitor.endVisit(this);
+        }
     }
 
     public void accept0(OracleASTVisitor visitor) {

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/expr/OracleDatetimeExpr.java

@@ -0,0 +1,48 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.expr;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleDatetimeExpr extends OracleSQLObjectImpl implements SQLExpr {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLExpr           expr;
+    private SQLExpr           timeZone;
+
+    public OracleDatetimeExpr(){
+
+    }
+
+    public OracleDatetimeExpr(SQLExpr expr, SQLExpr timeZone){
+        this.expr = expr;
+        this.timeZone = timeZone;
+    }
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, expr);
+            acceptChild(visitor, timeZone);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLExpr getExpr() {
+        return expr;
+    }
+
+    public void setExpr(SQLExpr expr) {
+        this.expr = expr;
+    }
+
+    public SQLExpr getTimeZone() {
+        return timeZone;
+    }
+
+    public void setTimeZone(SQLExpr timeZone) {
+        this.timeZone = timeZone;
+    }
+
+}

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/stmt/OracleAlterSessionStatement.java

@@ -0,0 +1,31 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.alibaba.druid.sql.ast.statement.SQLAssignItem;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleAlterSessionStatement extends OracleStatementImpl {
+
+    private static final long   serialVersionUID = 1L;
+
+    private List<SQLAssignItem> items            = new ArrayList<SQLAssignItem>();
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, items);
+        }
+        visitor.endVisit(this);
+    }
+
+    public List<SQLAssignItem> getItems() {
+        return items;
+    }
+
+    public void setItems(List<SQLAssignItem> items) {
+        this.items = items;
+    }
+
+}

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/stmt/OracleMethodInvokeStatement.java

@@ -0,0 +1,37 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleMethodInvokeStatement extends OracleStatementImpl {
+
+    private static final long   serialVersionUID = 1L;
+
+    private SQLMethodInvokeExpr expr;
+
+    public OracleMethodInvokeStatement(){
+
+    }
+
+    public OracleMethodInvokeStatement(SQLMethodInvokeExpr expr){
+        this.expr = expr;
+    }
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, expr);
+        }
+        visitor.endVisit(this);
+
+    }
+
+    public SQLMethodInvokeExpr getExpr() {
+        return expr;
+    }
+
+    public void setExpr(SQLMethodInvokeExpr expr) {
+        this.expr = expr;
+    }
+
+}

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/stmt/OracleTruncateStatement.java

@@ -0,0 +1,18 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.statement.SQLTruncateStatement;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+import com.alibaba.druid.sql.visitor.SQLASTVisitor;
+
+public class OracleTruncateStatement extends SQLTruncateStatement implements OracleStatement {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    protected void accept0(SQLASTVisitor visitor) {
+        this.accept0((OracleASTVisitor) visitor);
+    }
+
+    public  void accept0(OracleASTVisitor visitor) {
+    }
+}

src/main/java/com/alibaba/druid/sql/dialect/oracle/parser/OracleExprParser.java

@@ -29,6 +29,8 @@ import com.alibaba.druid.sql.ast.expr.SQLIntegerExpr;
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.alibaba.druid.sql.ast.expr.SQLNumberExpr;
 import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
+import com.alibaba.druid.sql.ast.expr.SQLUnaryExpr;
+import com.alibaba.druid.sql.ast.expr.SQLUnaryOperator;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleHint;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleOrderBy;
@@ -40,6 +42,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryFloatExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleCursorExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDateTimeUnit;
+import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDatetimeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDbLinkExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleExtractExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIntervalExpr;
@@ -90,6 +93,11 @@ public class OracleExprParser extends SQLExprParser {
 
         SQLExpr sqlExpr = null;
         switch (tok) {
+            case PRIOR:
+                lexer.nextToken();
+                sqlExpr = expr();
+                sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Prior, sqlExpr);
+                return primaryRest(sqlExpr);
             case COLON:
                 lexer.nextToken();
                 if (lexer.token() == Token.LITERAL_INT) {
@@ -204,6 +212,10 @@ public class OracleExprParser extends SQLExprParser {
                         sqlExpr = new OracleBinaryDoubleExpr(Double.parseDouble(lexer.numberString()) * -1);
                         lexer.nextToken();
                         break;
+                    case IDENTIFIER:
+                        sqlExpr = expr();
+                        sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Negative, sqlExpr);
+                        break;
                     default:
                         throw new ParserException("TODO");
                 }
@@ -286,6 +298,20 @@ public class OracleExprParser extends SQLExprParser {
             expr = interval;
         }
         
+        if (lexer.token() == Token.AT) {
+            lexer.nextToken();
+            if (lexer.token() == Token.LOCAL) {
+                lexer.nextToken();
+                expr = new OracleDatetimeExpr(expr, new SQLIdentifierExpr("LOCAL"));
+            } else {
+                accept(Token.TIME);
+                accept(Token.ZONE);
+                
+                SQLExpr timeZone = primary();
+                expr = new OracleDatetimeExpr(expr, timeZone);
+            }
+        }
+        
         SQLExpr restExpr = super.primaryRest(expr);
         
         if (restExpr != expr && restExpr instanceof SQLMethodInvokeExpr) {

src/main/java/com/alibaba/druid/sql/dialect/oracle/parser/OracleLexer.java

@@ -120,6 +120,11 @@ public class OracleLexer extends Lexer {
         map.put("MODE", Token.MODE);
         map.put("WAIT", Token.WAIT);
         map.put("NOWAIT", Token.NOWAIT);
+        map.put("SESSION", Token.SESSION);
+        map.put("AT", Token.AT);
+        map.put("LOCAL", Token.LOCAL);
+        map.put("TIME", Token.TIME);
+        map.put("ZONE", Token.ZONE);
 
         DEFAULT_ORACLE_KEYWORDS = new Keywords(map);
     }

src/main/java/com/alibaba/druid/sql/dialect/oracle/parser/OracleSelectParser.java

@@ -572,9 +572,49 @@ public class OracleSelectParser extends SQLSelectParser {
                 groupBy.setHaving(this.createExprParser().expr());
             }
 
+            queryBlock.setGroupBy(groupBy);
+        } else if (lexer.token() == (Token.HAVING)) {
+            lexer.nextToken();
+
+            SQLSelectGroupByClause groupBy = new SQLSelectGroupByClause();
+            groupBy.setHaving(this.createExprParser().expr());
+            
+            if (lexer.token() == (Token.GROUP)) {
+                lexer.nextToken();
+                accept(Token.BY);
+                
+                for (;;) {
+                    if (identifierEquals("GROUPING")) {
+                        GroupingSetExpr groupingSet = new GroupingSetExpr();
+                        lexer.nextToken();
+                        acceptIdentifier("SETS");
+                        accept(Token.LPAREN);
+                        createExprParser().exprList(groupingSet.getParameters());
+                        accept(Token.RPAREN);
+                        groupBy.getItems().add(groupingSet);
+                    } else {
+                        groupBy.getItems().add(this.createExprParser().expr());
+                    }
+
+                    if (!(lexer.token() == (Token.COMMA))) {
+                        break;
+                    }
+
+                    lexer.nextToken();
+                }
+            }
+            
             queryBlock.setGroupBy(groupBy);
         }
     }
+    
+    protected String as() throws ParserException {
+        if (lexer.token() == Token.CONNECT) {
+            return null;
+        }
+        
+        return super.as();
+    }
 
     private void parseHierachical(OracleSelectQueryBlock queryBlock) {
         OracleSelectHierachicalQueryClause hierachical = null;
@@ -814,7 +854,7 @@ public class OracleSelectParser extends SQLSelectParser {
 
         if (lexer.token() == Token.LEFT) {
             lexer.nextToken();
-            if (identifierEquals("OUTER")) {
+            if (lexer.token()  == Token.OUTER) {
                 lexer.nextToken();
             }
             accept(Token.JOIN);
@@ -823,16 +863,16 @@ public class OracleSelectParser extends SQLSelectParser {
 
         if (lexer.token() == Token.RIGHT) {
             lexer.nextToken();
-            if (identifierEquals("OUTER")) {
+            if (lexer.token()  == Token.OUTER) {
                 lexer.nextToken();
             }
             accept(Token.JOIN);
             joinType = OracleSelectJoin.JoinType.RIGHT_OUTER_JOIN;
         }
 
-        if (identifierEquals("FULL")) {
+        if (lexer.token()  == Token.FULL) {
             lexer.nextToken();
-            if (identifierEquals("OUTER")) {
+            if (lexer.token()  == Token.OUTER) {
                 lexer.nextToken();
             }
             accept(Token.JOIN);

src/main/java/com/alibaba/druid/sql/dialect/oracle/parser/OracleStatementParser.java

@@ -22,6 +22,7 @@ import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLStatement;
 import com.alibaba.druid.sql.ast.expr.SQLBinaryOpExpr;
 import com.alibaba.druid.sql.ast.expr.SQLBinaryOperator;
+import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.alibaba.druid.sql.ast.statement.SQLInsertInto;
 import com.alibaba.druid.sql.ast.statement.SQLSelect;
 import com.alibaba.druid.sql.ast.statement.SQLSelectStatement;
@@ -31,14 +32,16 @@ import com.alibaba.druid.sql.ast.statement.SQLUpdateSetItem;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleHint;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleErrorLoggingClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement.LockMode;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMethodInvokeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OraclePLSQLCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleStatement;
-import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement.LockMode;
 import com.alibaba.druid.sql.parser.Lexer;
 import com.alibaba.druid.sql.parser.ParserException;
 import com.alibaba.druid.sql.parser.SQLStatementParser;
@@ -60,7 +63,7 @@ public class OracleStatementParser extends SQLStatementParser {
     protected OracleExprParser createExprParser() {
         return new OracleExprParser(lexer);
     }
-    
+
     protected void parseInsert0_hinits(SQLInsertInto insertStatement) {
         if (insertStatement instanceof OracleInsertStatement) {
             OracleInsertStatement stmt = (OracleInsertStatement) insertStatement;
@@ -119,7 +122,8 @@ public class OracleStatementParser extends SQLStatementParser {
             }
 
             if (lexer.token() == Token.ALTER) {
-                throw new ParserException("TODO");
+                statementList.add(parserAlter());
+                continue;
             }
 
             if (lexer.token() == Token.WITH) {
@@ -146,6 +150,11 @@ public class OracleStatementParser extends SQLStatementParser {
                 statementList.add(this.parseLock());
                 continue;
             }
+            
+            if (lexer.token() == Token.TRUNCATE) {
+                statementList.add(this.parseTruncate());
+                continue;
+            }
 
             if (lexer.token() == Token.VARIANT) {
                 SQLExpr variant = this.exprParser.primary();
@@ -164,10 +173,42 @@ public class OracleStatementParser extends SQLStatementParser {
                 statementList.add(stmt);
                 continue;
             }
+            
+            if (lexer.token() == Token.IDENTIFIER) {
+                SQLExpr expr = exprParser.expr();
+                if (expr instanceof SQLMethodInvokeExpr) {
+                    OracleMethodInvokeStatement stmt = new OracleMethodInvokeStatement((SQLMethodInvokeExpr) expr);
+                    statementList.add(stmt);
+                    continue;
+                } else {
+                    throw new ParserException("expr : " + expr);
+                }
+            }
 
             throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
         }
     }
+    
+    public SQLStatement parseTruncate() {
+        return super.parseTruncate();
+    }
+
+    public OracleStatement parserAlter() {
+        accept(Token.ALTER);
+        if (lexer.token() == Token.SESSION) {
+            lexer.nextToken();
+            
+            OracleAlterSessionStatement stmt = new OracleAlterSessionStatement();
+            if (lexer.token() == Token.SET) {
+                lexer.nextToken();
+                parseAssignItems(stmt.getItems());
+            } else {
+                throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());        
+            }
+            return stmt;
+        }
+        throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+    }
 
     public OracleLockTableStatement parseLock() {
         accept(Token.LOCK);
@@ -185,7 +226,7 @@ public class OracleStatementParser extends SQLStatementParser {
             lexer.nextToken();
         }
         accept(Token.MODE);
-        
+
         if (lexer.token() == Token.NOWAIT) {
             lexer.nextToken();
         } else if (lexer.token() == Token.WAIT) {
@@ -313,9 +354,14 @@ public class OracleStatementParser extends SQLStatementParser {
     public OracleStatement parseInsert() {
         accept(Token.INSERT);
 
+        List<OracleHint> hints = new ArrayList<OracleHint>();
+        
+        this.createExprParser().parseHints(hints);
+        
         if (lexer.token() == Token.INTO) {
             OracleInsertStatement stmt = new OracleInsertStatement();
-
+            stmt.setHints(hints);
+            
             parseInsert0(stmt);
 
             stmt.setReturning(parseReturningClause());
@@ -324,10 +370,12 @@ public class OracleStatementParser extends SQLStatementParser {
             return stmt;
         }
 
-        return parseMultiInsert();
+        OracleMultiInsertStatement stmt = parseMultiInsert();
+        stmt.setHints(hints);
+        return stmt;
     }
 
-    public OracleStatement parseMultiInsert() {
+    public OracleMultiInsertStatement parseMultiInsert() {
         OracleMultiInsertStatement stmt = new OracleMultiInsertStatement();
 
         if (lexer.token() == Token.ALL) {

src/main/java/com/alibaba/druid/sql/dialect/oracle/visitor/OracleASTVIsitorAdapter.java

@@ -30,12 +30,14 @@ import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryDoubleExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryFloatExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleCursorExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDateExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDatetimeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDbLinkExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleExtractExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIntervalExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIsSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleOuterExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
@@ -44,6 +46,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement.MergeInsertClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement.MergeUpdateClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMethodInvokeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.ConditionalInsertClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.ConditionalInsertClauseItem;
@@ -700,85 +703,85 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora
     public void endVisit(OracleErrorLoggingClause x) {
 
     }
-    
+
     @Override
     public boolean visit(OracleReturningClause x) {
         return true;
     }
-    
+
     @Override
     public void endVisit(OracleReturningClause x) {
-        
+
     }
-    
+
     @Override
     public boolean visit(OracleInsertStatement x) {
         return true;
     }
-    
+
     @Override
     public void endVisit(OracleInsertStatement x) {
-        
+
     }
-    
+
     @Override
     public boolean visit(InsertIntoClause x) {
         return true;
     }
-    
+
     @Override
     public void endVisit(InsertIntoClause x) {
-        
+
     }
-    
+
     @Override
     public boolean visit(OracleMultiInsertStatement x) {
         return true;
     }
-    
+
     @Override
     public void endVisit(OracleMultiInsertStatement x) {
-        
+
     }
-    
+
     @Override
     public boolean visit(ConditionalInsertClause x) {
         return true;
     }
-    
+
     @Override
     public void endVisit(ConditionalInsertClause x) {
-        
+
     }
-    
+
     @Override
     public boolean visit(ConditionalInsertClauseItem x) {
         return true;
     }
-    
+
     @Override
     public void endVisit(ConditionalInsertClauseItem x) {
-        
+
     }
-    
+
     @Override
     public boolean visit(OracleSelectQueryBlock x) {
         return true;
     }
-    
+
     @Override
     public void endVisit(OracleSelectQueryBlock x) {
-        
+
     }
-    
+
     @Override
     public boolean visit(OracleBlockStatement x) {
         return true;
     }
-    
+
     @Override
     public void endVisit(OracleBlockStatement x) {
-        
+
     }
 
     @Override
@@ -788,6 +791,36 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora
 
     @Override
     public void endVisit(OracleLockTableStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterSessionStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleAlterSessionStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleMethodInvokeStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleMethodInvokeStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleDatetimeExpr x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleDatetimeExpr x) {
         
     }
 

src/main/java/com/alibaba/druid/sql/dialect/oracle/visitor/OracleASTVisitor.java

@@ -36,18 +36,21 @@ import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryDoubleExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryFloatExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleCursorExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDateExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDatetimeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDbLinkExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleExtractExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIntervalExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIsSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleOuterExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMethodInvokeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.ConditionalInsertClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.ConditionalInsertClauseItem;
@@ -345,4 +348,16 @@ public interface OracleASTVisitor extends SQLASTVisitor {
     boolean visit(OracleLockTableStatement x);
     
     void endVisit(OracleLockTableStatement x);
+    
+    boolean visit(OracleAlterSessionStatement x);
+    
+    void endVisit(OracleAlterSessionStatement x);
+    
+    boolean visit(OracleMethodInvokeStatement x);
+    
+    void endVisit(OracleMethodInvokeStatement x);
+    
+    boolean visit(OracleDatetimeExpr x);
+    
+    void endVisit(OracleDatetimeExpr x);
 }

src/main/java/com/alibaba/druid/sql/dialect/oracle/visitor/OracleOutputVisitor.java

@@ -24,6 +24,7 @@ import com.alibaba.druid.sql.ast.SQLObject;
 import com.alibaba.druid.sql.ast.SQLSetQuantifier;
 import com.alibaba.druid.sql.ast.SQLStatement;
 import com.alibaba.druid.sql.ast.expr.SQLAllColumnExpr;
+import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr;
 import com.alibaba.druid.sql.ast.expr.SQLLiteralExpr;
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.alibaba.druid.sql.ast.expr.SQLObjectCreateExpr;
@@ -62,12 +63,14 @@ import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryDoubleExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryFloatExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleCursorExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDateExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDatetimeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDbLinkExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleExtractExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIntervalExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIsSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleOuterExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
@@ -76,6 +79,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement.MergeInsertClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement.MergeUpdateClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMethodInvokeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.ConditionalInsertClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.ConditionalInsertClauseItem;
@@ -1669,4 +1673,50 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
     public void endVisit(OracleLockTableStatement x) {
         
     }
+
+    @Override
+    public boolean visit(OracleAlterSessionStatement x) {
+        print("ALTER SESSION SET ");
+        printAndAccept(x.getItems(), ", ");
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterSessionStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleMethodInvokeStatement x) {
+        x.getExpr().accept(this);
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleMethodInvokeStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleDatetimeExpr x) {
+        x.getExpr().accept(this);
+        SQLExpr timeZone = x.getTimeZone();
+        
+        if (timeZone instanceof SQLIdentifierExpr) {
+            if (((SQLIdentifierExpr) timeZone).getName().equalsIgnoreCase("LOCAL")) {
+                print(" AT LOCAL");
+                return false;
+            }
+        }
+        
+        print(" AT TIME ZONE ");
+        timeZone.accept(this);
+        
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleDatetimeExpr x) {
+        
+    }
 }

src/main/java/com/alibaba/druid/sql/dialect/oracle/visitor/OracleSchemaStatVisitor.java

@@ -45,12 +45,14 @@ import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryDoubleExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleBinaryFloatExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleCursorExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDateExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDatetimeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleDbLinkExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleExtractExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIntervalExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIsSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleOuterExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
@@ -59,6 +61,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement.MergeInsertClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement.MergeUpdateClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMethodInvokeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.ConditionalInsertClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.ConditionalInsertClauseItem;
@@ -95,28 +98,28 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
         if (expr instanceof OracleOuterExpr) {
             expr = ((OracleOuterExpr) expr).getExpr();
         }
-        
+
         return super.getColumn(expr);
     }
-    
+
     public boolean visit(OracleSelectTableReference x) {
         SQLExpr expr = x.getExpr();
-        
+
         if (expr instanceof SQLMethodInvokeExpr) {
             SQLMethodInvokeExpr methodInvoke = (SQLMethodInvokeExpr) expr;
             if ("TABLE".equalsIgnoreCase(methodInvoke.getMethodName()) && methodInvoke.getParameters().size() == 1) {
                 expr = methodInvoke.getParameters().get(0);
             }
         }
-        
+
         Map<String, String> aliasMap = aliasLocal.get();
-        
+
         if (expr instanceof SQLName) {
             String ident;
             if (expr instanceof SQLPropertyExpr) {
                 String owner = ((SQLPropertyExpr) expr).getOwner().toString();
                 String name = ((SQLPropertyExpr) expr).getName();
-                
+
                 if (aliasMap.containsKey(owner)) {
                     owner = aliasMap.get(owner);
                 }
@@ -124,11 +127,11 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
             } else {
                 ident = expr.toString();
             }
-            
+
             if (subQueryMap.containsKey(ident)) {
                 return false;
             }
-            
+
             if ("DUAL".equalsIgnoreCase(ident)) {
                 return false;
             }
@@ -254,7 +257,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
         if (x.getWhere() != null) {
             x.getWhere().setParent(x);
         }
-        
+
         return visit((SQLSelectQueryBlock) x);
     }
 
@@ -269,7 +272,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
         return super.visit(x);
     }
-    
+
     public boolean visit(SQLMethodInvokeExpr x) {
         accept(x.getParameters());
         return false;
@@ -287,7 +290,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
         if ("+".equalsIgnoreCase(x.getName())) {
             return false;
         }
-        
+
         if ("LEVEL".equals(x.getName())) {
             return false;
         }
@@ -530,7 +533,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
         if (x.getCondition() != null) {
             x.getCondition().accept(this);
         }
-        
+
         for (SQLExpr item : x.getUsing()) {
             if (item instanceof SQLIdentifierExpr) {
                 String columnName = ((SQLIdentifierExpr) item).getName();
@@ -543,17 +546,17 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
                     relationship.setOperator("USING");
                     relationships.add(relationship);
                 }
-                
+
                 if (leftTable != null) {
                     columns.add(new Column(leftTable, columnName));
                 }
-                
+
                 if (rightTable != null) {
                     columns.add(new Column(rightTable, columnName));
                 }
             }
         }
-        
+
         return false;
     }
 
@@ -1090,7 +1093,6 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
     @Override
     public void endVisit(ConditionalInsertClauseItem x) {
 
-
     }
 
     @Override
@@ -1100,8 +1102,29 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleBlockStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterSessionStatement x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterSessionStatement x) {
+
+    }
+    
+    @Override
+    public boolean visit(OracleMethodInvokeStatement x) {
+        return false;
+    }
+    
+    @Override
+    public void endVisit(OracleMethodInvokeStatement x) {
         
     }
+
     @Override
     public boolean visit(OracleLockTableStatement x) {
         String tableName = x.getTable().toString();
@@ -1109,9 +1132,19 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
         this.tableStats.put(new TableStat.Name(tableName), stat);
         return false;
     }
-    
+
     @Override
     public void endVisit(OracleLockTableStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleDatetimeExpr x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleDatetimeExpr x) {
         
     }
 }

src/main/java/com/alibaba/druid/sql/parser/Keywords.java

@@ -101,6 +101,10 @@ public class Keywords {
         map.put("DEFAULT", Token.DEFAULT);
         DEFAULT_KEYWORDS = new Keywords(map);
     }
+    
+    public boolean containsValue(Token token) {
+        return this.keywords.containsValue(token);
+    }
 
     public Keywords(Map<String, Token> keywords){
         this.keywords = keywords;

src/main/java/com/alibaba/druid/sql/parser/Lexer.java

@@ -19,7 +19,6 @@ import static com.alibaba.druid.sql.parser.CharTypes.isFirstIdentifierChar;
 import static com.alibaba.druid.sql.parser.CharTypes.isIdentifierChar;
 import static com.alibaba.druid.sql.parser.CharTypes.isWhitespace;
 import static com.alibaba.druid.sql.parser.LayoutCharacters.EOI;
-import static com.alibaba.druid.sql.parser.Token.COLON;
 import static com.alibaba.druid.sql.parser.Token.COLONEQ;
 import static com.alibaba.druid.sql.parser.Token.COMMA;
 import static com.alibaba.druid.sql.parser.Token.EOF;
@@ -91,6 +90,10 @@ public class Lexer {
         Token token;
     }
 
+    public Keywords getKeywods() {
+        return keywods;
+    }
+
     public void mark() {
         SavePoint savePoint = new SavePoint();
         savePoint.bp = bp;
@@ -144,7 +147,7 @@ public class Lexer {
     protected final void scanChar() {
         ch = buf[++bp];
     }
-    
+
     protected void unscan() {
         ch = buf[--bp];
     }

src/main/java/com/alibaba/druid/sql/parser/SQLExprParser.java

@@ -201,6 +201,14 @@ public class SQLExprParser extends SQLParser {
             case USER:
             case PASSWORD:
             case DUAL:
+            case REFERENCE:
+            case KEY:
+            case DISTINCT:
+            case YEAR:
+            case MONTH:
+            case TIME:
+            case ZONE:
+            case LOG:
                 sqlExpr = new SQLIdentifierExpr(lexer.stringVal());
                 lexer.nextToken();
                 break;
@@ -250,9 +258,10 @@ public class SQLExprParser extends SQLParser {
                     sqlExpr = new SQLExistsExpr(createSelectParser().select(), true);
                     accept(Token.RPAREN);
                 } else if (lexer.token() == Token.LPAREN) {
-                    lexer.token();
+                    lexer.nextToken();
 
-                    sqlExpr = new SQLNotExpr(expr());
+                    SQLExpr notTarget = expr();
+                    sqlExpr = new SQLNotExpr(notTarget);
 
                     accept(Token.RPAREN);
                     return primaryRest(sqlExpr);
@@ -393,13 +402,6 @@ public class SQLExprParser extends SQLParser {
 
                 sqlExpr = someExpr;
                 break;
-            case KEY:
-            case DISTINCT:
-            case YEAR:
-            case MONTH:
-                lexer.nextToken();
-                sqlExpr = new SQLIdentifierExpr(tok.name());
-                break;
             case ALL:
                 lexer.nextToken();
                 SQLAllExpr allExpr = new SQLAllExpr();
@@ -476,14 +478,14 @@ public class SQLExprParser extends SQLParser {
         } else {
             String name;
 
-            if (lexer.token() == Token.KEY) {
-                name = "KEY";
-                lexer.nextToken();
-            } else if (lexer.token() != Token.IDENTIFIER && lexer.token() != Token.USER && lexer.token() != Token.PASSWORD) {
-                throw new ParserException("error : " + lexer.stringVal());
-            } else {
+            if (lexer.token() == Token.IDENTIFIER || lexer.token() == Token.LITERAL_CHARS || lexer.token() == Token.LITERAL_ALIAS) {
                 name = lexer.stringVal();
                 lexer.nextToken();
+            } else if (lexer.getKeywods().containsValue(lexer.token())) {
+                name = lexer.stringVal();
+                lexer.nextToken();
+            } else {
+                throw new ParserException("error : " + lexer.stringVal());
             }
 
             if (lexer.token() == Token.LPAREN) {
@@ -569,6 +571,12 @@ public class SQLExprParser extends SQLParser {
 
         if (lexer.token() == Token.DOT) {
             lexer.nextToken();
+            
+            if (lexer.token() == Token.KEY) {
+                name = new SQLPropertyExpr(name, "KEY");
+                lexer.nextToken();
+                return name;
+            }
 
             if (lexer.token() != Token.LITERAL_ALIAS && lexer.token() != Token.IDENTIFIER) {
                 throw new ParserException("error, " + lexer.token());
@@ -914,9 +922,9 @@ public class SQLExprParser extends SQLParser {
             expr = notRationalRest(expr);
         } else if (lexer.token() == (Token.BETWEEN)) {
             lexer.nextToken();
-            SQLExpr beginExpr = primary();
+            SQLExpr beginExpr = bitOr();
             accept(Token.AND);
-            SQLExpr endExpr = primary();
+            SQLExpr endExpr = bitOr();
             expr = new SQLBetweenExpr(expr, beginExpr, endExpr);
         } else if (lexer.token() == (Token.IS)) {
             lexer.nextToken();
@@ -975,9 +983,9 @@ public class SQLExprParser extends SQLParser {
             return expr;
         } else if (lexer.token() == (Token.BETWEEN)) {
             lexer.nextToken();
-            SQLExpr beginExpr = primary();
+            SQLExpr beginExpr = bitOr();
             accept(Token.AND);
-            SQLExpr endExpr = primary();
+            SQLExpr endExpr = bitOr();
 
             expr = new SQLBetweenExpr(expr, true, beginExpr, endExpr);
 

src/main/java/com/alibaba/druid/sql/parser/SQLParser.java

@@ -65,7 +65,7 @@ public class SQLParser {
                 return alias;
             }
 
-            if (lexer.token() == Token.YEAR || lexer.token() == Token.DAY) {
+            if (lexer.token() == Token.YEAR || lexer.token() == Token.DAY || lexer.token() == Token.KEY || lexer.token() == Token.CASE) {
                 alias = lexer.token.name();
                 lexer.nextToken();
                 return alias;
@@ -92,7 +92,7 @@ public class SQLParser {
         } else if (lexer.token() == Token.LITERAL_CHARS) {
             alias = "'" + lexer.stringVal() + "'";
             lexer.nextToken();
-        } else if (lexer.token() == Token.YEAR || lexer.token() == Token.DAY) {
+        } else if (lexer.token() == Token.YEAR || lexer.token() == Token.DAY || lexer.token() == Token.CASE) {
             alias = lexer.token.name();
             lexer.nextToken();
         }
@@ -114,7 +114,8 @@ public class SQLParser {
             lexer.nextToken();
         } else {
             setErrorEndPos(lexer.pos());
-            throw new SQLParseException("syntax error, expect " + token + ", actual " + lexer.token() + " " + lexer.stringVal());
+            throw new SQLParseException("syntax error, expect " + token + ", actual " + lexer.token() + " "
+                                        + lexer.stringVal());
         }
     }
 

src/main/java/com/alibaba/druid/sql/parser/SQLSelectParser.java

@@ -167,6 +167,12 @@ public class SQLSelectParser extends SQLParser {
                 groupBy.setHaving(expr());
             }
 
+            queryBlock.setGroupBy(groupBy);
+        } else if (lexer.token() == (Token.HAVING)) {
+            lexer.nextToken();
+
+            SQLSelectGroupByClause groupBy = new SQLSelectGroupByClause();
+            groupBy.setHaving(this.createExprParser().expr());
             queryBlock.setGroupBy(groupBy);
         }
     }

src/main/java/com/alibaba/druid/sql/parser/SQLStatementParser.java

@@ -22,6 +22,7 @@ import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLName;
 import com.alibaba.druid.sql.ast.SQLStatement;
 import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
+import com.alibaba.druid.sql.ast.statement.SQLAssignItem;
 import com.alibaba.druid.sql.ast.statement.SQLCallStatement;
 import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
 import com.alibaba.druid.sql.ast.statement.SQLCreateViewStatement;
@@ -32,6 +33,7 @@ import com.alibaba.druid.sql.ast.statement.SQLInsertStatement;
 import com.alibaba.druid.sql.ast.statement.SQLSelectStatement;
 import com.alibaba.druid.sql.ast.statement.SQLSetStatement;
 import com.alibaba.druid.sql.ast.statement.SQLTableSource;
+import com.alibaba.druid.sql.ast.statement.SQLTruncateStatement;
 import com.alibaba.druid.sql.ast.statement.SQLUpdateSetItem;
 import com.alibaba.druid.sql.ast.statement.SQLUpdateStatement;
 
@@ -157,7 +159,23 @@ public class SQLStatementParser extends SQLParser {
     }
 
     public SQLStatement parseTruncate() {
-        throw new ParserException("TODO " + lexer.token());
+        accept(Token.TRUNCATE);
+        accept(Token.TABLE);
+        SQLTruncateStatement stmt = new SQLTruncateStatement();
+        
+        for (;;) {
+            SQLName name = this.exprParser.name();
+            stmt.getTableNames().add(name);
+
+            if (lexer.token() == Token.COMMA) {
+                lexer.nextToken();
+                continue;
+            }
+
+            break;
+        }
+
+        return stmt;
     }
 
     public SQLStatement parseInsert() {
@@ -236,13 +254,19 @@ public class SQLStatementParser extends SQLParser {
         accept(Token.SET);
         SQLSetStatement stmt = new SQLSetStatement();
 
+        parseAssignItems(stmt.getItems());
+
+        return stmt;
+    }
+
+    public void parseAssignItems(List<SQLAssignItem> items) {
         for (;;) {
-            SQLSetStatement.Item item = new SQLSetStatement.Item();
+            SQLAssignItem item = new SQLAssignItem();
             item.setTarget(exprParser.primary());
             accept(Token.EQ);
             item.setValue(exprParser.expr());
 
-            stmt.getItems().add(item);
+            items.add(item);
 
             if (lexer.token() == Token.COMMA) {
                 lexer.nextToken();
@@ -251,8 +275,6 @@ public class SQLStatementParser extends SQLParser {
                 break;
             }
         }
-
-        return stmt;
     }
 
     public SQLStatement parseCreate() throws ParserException {

src/main/java/com/alibaba/druid/sql/parser/Token.java

@@ -155,6 +155,12 @@ public enum Token {
     EXCLUSIVE("EXCLUSIVE"),
     MODE("MODE"),
     WAIT("WAIT"),
+    ADVISE("ADVISE"),
+    SESSION("SESSION"),
+    AT("AT"),
+    LOCAL("LOCAL"),
+    TIME("TIME"),
+    ZONE("ZONE"),
     
     // transact-sql
     TOP("TOP"),

src/main/java/com/alibaba/druid/sql/visitor/SQLASTOutputVisitor.java

@@ -53,6 +53,7 @@ import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
 import com.alibaba.druid.sql.ast.expr.SQLSomeExpr;
 import com.alibaba.druid.sql.ast.expr.SQLUnaryExpr;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
+import com.alibaba.druid.sql.ast.statement.SQLAssignItem;
 import com.alibaba.druid.sql.ast.statement.NotNullConstraint;
 import com.alibaba.druid.sql.ast.statement.SQLCallStatement;
 import com.alibaba.druid.sql.ast.statement.SQLColumnConstraint;
@@ -746,7 +747,7 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter {
     }
 
     @Override
-    public boolean visit(SQLSetStatement.Item x) {
+    public boolean visit(SQLAssignItem x) {
         x.getTarget().accept(this);
         print(" = ");
         x.getValue().accept(this);

src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitor.java

@@ -50,6 +50,7 @@ import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
 import com.alibaba.druid.sql.ast.expr.SQLSomeExpr;
 import com.alibaba.druid.sql.ast.expr.SQLUnaryExpr;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
+import com.alibaba.druid.sql.ast.statement.SQLAssignItem;
 import com.alibaba.druid.sql.ast.statement.NotNullConstraint;
 import com.alibaba.druid.sql.ast.statement.SQLCallStatement;
 import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
@@ -281,9 +282,9 @@ public interface SQLASTVisitor {
 
     boolean visit(SQLSetStatement x);
 
-    void endVisit(SQLSetStatement.Item x);
+    void endVisit(SQLAssignItem x);
 
-    boolean visit(SQLSetStatement.Item x);
+    boolean visit(SQLAssignItem x);
 
     void endVisit(SQLCallStatement x);
 

src/main/java/com/alibaba/druid/sql/visitor/SQLASTVisitorAdapter.java

@@ -50,6 +50,7 @@ import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
 import com.alibaba.druid.sql.ast.expr.SQLSomeExpr;
 import com.alibaba.druid.sql.ast.expr.SQLUnaryExpr;
 import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
+import com.alibaba.druid.sql.ast.statement.SQLAssignItem;
 import com.alibaba.druid.sql.ast.statement.NotNullConstraint;
 import com.alibaba.druid.sql.ast.statement.SQLCallStatement;
 import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
@@ -443,12 +444,12 @@ public class SQLASTVisitorAdapter implements SQLASTVisitor {
     }
 
     @Override
-    public void endVisit(SQLSetStatement.Item x) {
+    public void endVisit(SQLAssignItem x) {
 
     }
 
     @Override
-    public boolean visit(SQLSetStatement.Item x) {
+    public boolean visit(SQLAssignItem x) {
         return true;
     }
 

src/main/java/com/alibaba/druid/sql/visitor/SchemaStatVisitor.java

@@ -20,6 +20,7 @@ import com.alibaba.druid.sql.ast.expr.SQLInSubQueryExpr;
 import com.alibaba.druid.sql.ast.expr.SQLIntegerExpr;
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
+import com.alibaba.druid.sql.ast.statement.SQLCallStatement;
 import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
 import com.alibaba.druid.sql.ast.statement.SQLDeleteStatement;
@@ -677,7 +678,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
 
         setMode(x, Mode.Delete);
 
-        String ident = ((SQLIdentifierExpr) x.getTableName()).getName();
+        String ident = x.getTableName().toString();
         currentTableLocal.set(ident);
 
         TableStat stat = tableStats.get(ident);
@@ -753,4 +754,9 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
 
         return false;
     }
+    
+    @Override
+    public boolean visit(SQLCallStatement x) {
+        return false;
+    }
 }