bug fixed for sql parser

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

@@ -25,6 +25,7 @@ public class SQLDeleteStatement extends SQLStatementImpl {
     private static final long serialVersionUID = 1L;
     protected SQLName         tableName;
     protected SQLExpr         where;
+    private String            alias;
 
     public SQLDeleteStatement(){
 
@@ -46,6 +47,14 @@ public class SQLDeleteStatement extends SQLStatementImpl {
         this.where = where;
     }
 
+    public String getAlias() {
+        return this.alias;
+    }
+
+    public void setAlias(String alias) {
+        this.alias = alias;
+    }
+
     public void output(StringBuffer buf) {
         buf.append("DELETE FROM ");
         this.tableName.output(buf);

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/clause/OraclePartitionByRangeClause.java

@@ -0,0 +1,65 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.clause;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OraclePartitionByRangeClause extends OracleSQLObjectImpl implements OraclePartitioningClause {
+
+    private static final long             serialVersionUID = 1L;
+
+    private List<SQLName>                 columns          = new ArrayList<SQLName>();
+
+    private SQLExpr                       interval;
+    private List<SQLName>                 storeIn          = new ArrayList<SQLName>();
+
+    private List<OracleRangeValuesClause> ranges           = new ArrayList<OracleRangeValuesClause>();
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, columns);
+            acceptChild(visitor, interval);
+            acceptChild(visitor, storeIn);
+            acceptChild(visitor, ranges);
+        }
+        visitor.endVisit(this);
+    }
+
+    public List<OracleRangeValuesClause> getRanges() {
+        return ranges;
+    }
+
+    public void setRanges(List<OracleRangeValuesClause> ranges) {
+        this.ranges = ranges;
+    }
+
+    public List<SQLName> getStoreIn() {
+        return storeIn;
+    }
+
+    public void setStoreIn(List<SQLName> storeIn) {
+        this.storeIn = storeIn;
+    }
+
+    public SQLExpr getInterval() {
+        return interval;
+    }
+
+    public void setInterval(SQLExpr interval) {
+        this.interval = interval;
+    }
+
+    public List<SQLName> getColumns() {
+        return columns;
+    }
+
+    public void setColumns(List<SQLName> columns) {
+        this.columns = columns;
+    }
+
+}

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/clause/OraclePartitioningClause.java

@@ -0,0 +1,8 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.clause;
+
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObject;
+
+
+public interface OraclePartitioningClause extends OracleSQLObject {
+
+}

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/clause/OracleRangeValuesClause.java

@@ -0,0 +1,43 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.clause;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleRangeValuesClause extends OracleSQLObjectImpl {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLName           name;
+    private List<SQLExpr>     values           = new ArrayList<SQLExpr>();
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+            acceptChild(visitor, values);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+    public List<SQLExpr> getValues() {
+        return values;
+    }
+
+    public void setValues(List<SQLExpr> values) {
+        this.values = values;
+    }
+
+}

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/clause/OracleStorageClause.java

@@ -1,7 +1,6 @@
 package com.alibaba.druid.sql.dialect.oracle.ast.clause;
 
 import com.alibaba.druid.sql.ast.SQLExpr;
-import com.alibaba.druid.sql.ast.SQLName;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
 import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
 

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

@@ -0,0 +1,87 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleCreateSequenceStatement extends OracleStatementImpl {
+
+    private static final long serialVersionUID = 1L;
+    private SQLName           name;
+
+    private SQLExpr           startWith;
+    private SQLExpr           incrementBy;
+    private SQLExpr           maxValue;
+
+    private Boolean           cycle;
+    private Boolean           cache;
+    private Boolean           order;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+            acceptChild(visitor, startWith);
+            acceptChild(visitor, incrementBy);
+            acceptChild(visitor, maxValue);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+    public SQLExpr getStartWith() {
+        return startWith;
+    }
+
+    public void setStartWith(SQLExpr startWith) {
+        this.startWith = startWith;
+    }
+
+    public SQLExpr getIncrementBy() {
+        return incrementBy;
+    }
+
+    public void setIncrementBy(SQLExpr incrementBy) {
+        this.incrementBy = incrementBy;
+    }
+
+    public SQLExpr getMaxValue() {
+        return maxValue;
+    }
+
+    public void setMaxValue(SQLExpr maxValue) {
+        this.maxValue = maxValue;
+    }
+
+    public Boolean getCycle() {
+        return cycle;
+    }
+
+    public void setCycle(Boolean cycle) {
+        this.cycle = cycle;
+    }
+
+    public Boolean getCache() {
+        return cache;
+    }
+
+    public void setCache(Boolean cache) {
+        this.cache = cache;
+    }
+
+    public Boolean getOrder() {
+        return order;
+    }
+
+    public void setOrder(Boolean order) {
+        this.order = order;
+    }
+
+}

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

@@ -1,44 +1,62 @@
 package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLName;
 import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
 import com.alibaba.druid.sql.ast.statement.SQLSelect;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OraclePartitioningClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleStorageClause;
 import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
 import com.alibaba.druid.sql.visitor.SQLASTVisitor;
 
 public class OracleCreateTableStatement extends SQLCreateTableStatement implements OracleStatement {
 
-    private static final long   serialVersionUID  = 1L;
+    private static final long        serialVersionUID  = 1L;
 
-    private SQLName             tablespace;
+    private SQLName                  tablespace;
 
-    private SQLSelect           select;
+    private SQLSelect                select;
 
-    private boolean             inMemoryMetadata;
+    private boolean                  inMemoryMetadata;
 
-    private boolean             cursorSpecificSegment;
+    private boolean                  cursorSpecificSegment;
 
     // NOPARALLEL
-    private Boolean             parallel;
+    private Boolean                  parallel;
 
-    private OracleStorageClause storage;
+    private OracleStorageClause      storage;
 
-    private boolean             organizationIndex = false;
+    private boolean                  organizationIndex = false;
 
-    private SQLExpr             ptcfree;
-    private SQLExpr             pctused;
-    private SQLExpr             initrans;
-    private SQLExpr             maxtrans;
+    private SQLExpr                  ptcfree;
+    private SQLExpr                  pctused;
+    private SQLExpr                  initrans;
+    private SQLExpr                  maxtrans;
 
-    private Boolean             logging;
-    private Boolean             compress;
-    private boolean             onCommit;
-    private boolean             preserveRows;
+    private Boolean                  logging;
+    private Boolean                  compress;
+    private boolean                  onCommit;
+    private boolean                  preserveRows;
+
+    private Boolean                  cache;
+
+    private OraclePartitioningClause partitioning;
+
+    public OraclePartitioningClause getPartitioning() {
+        return partitioning;
+    }
+
+    public void setPartitioning(OraclePartitioningClause partitioning) {
+        this.partitioning = partitioning;
+    }
+
+    public Boolean getCache() {
+        return cache;
+    }
+
+    public void setCache(Boolean cache) {
+        this.cache = cache;
+    }
 
     public boolean isOnCommit() {
         return onCommit;
@@ -171,6 +189,7 @@ public class OracleCreateTableStatement extends SQLCreateTableStatement implemen
             this.acceptChild(visitor, tablespace);
             this.acceptChild(visitor, select);
             this.acceptChild(visitor, storage);
+            this.acceptChild(visitor, partitioning);
         }
         visitor.endVisit(this);
     }

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

@@ -29,7 +29,7 @@ public class OracleDeleteStatement extends SQLDeleteStatement {
     private static final long      serialVersionUID = 1L;
 
     private boolean                only             = false;
-    private String                 alias;
+    
     private final List<OracleHint> hints            = new ArrayList<OracleHint>();
     private OracleReturningClause  returning        = null;
 
@@ -72,11 +72,5 @@ public class OracleDeleteStatement extends SQLDeleteStatement {
         this.only = only;
     }
 
-    public String getAlias() {
-        return this.alias;
-    }
-
-    public void setAlias(String alias) {
-        this.alias = alias;
-    }
+ 
 }

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

@@ -0,0 +1,27 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleExitStatement extends OracleStatementImpl {
+
+    private static final long serialVersionUID = 1L;
+    private SQLExpr when;
+
+    public SQLExpr getWhen() {
+        return when;
+    }
+
+    public void setWhen(SQLExpr when) {
+        this.when = when;
+    }
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, when);
+        }
+        visitor.endVisit(this);
+    }
+
+}

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/stmt/OracleLoopStatement.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.SQLStatement;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleLoopStatement extends OracleStatementImpl {
+
+    private static final long  serialVersionUID = 1L;
+
+    private List<SQLStatement> statements       = new ArrayList<SQLStatement>();
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, statements);
+        }
+        visitor.endVisit(this);
+    }
+
+    public List<SQLStatement> getStatements() {
+        return statements;
+    }
+
+    public void setStatements(List<SQLStatement> statements) {
+        this.statements = statements;
+    }
+
+}

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

@@ -1,9 +1,14 @@
 package com.alibaba.druid.sql.dialect.oracle.parser;
 
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OraclePartitionByRangeClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleRangeValuesClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleStorageClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelect;
 import com.alibaba.druid.sql.parser.Lexer;
+import com.alibaba.druid.sql.parser.ParserException;
 import com.alibaba.druid.sql.parser.SQLCreateTableParser;
 import com.alibaba.druid.sql.parser.Token;
 
@@ -48,6 +53,14 @@ public class OracleCreateTableParser extends SQLCreateTableParser {
                 lexer.nextToken();
                 stmt.setLogging(Boolean.TRUE);
                 continue;
+            } else if (identifierEquals("CACHE")) {
+                lexer.nextToken();
+                stmt.setCache(Boolean.TRUE);
+                continue;
+            } else if (identifierEquals("NOCACHE")) {
+                lexer.nextToken();
+                stmt.setCache(Boolean.FALSE);
+                continue;
             } else if (identifierEquals("NOCOMPRESS")) {
                 lexer.nextToken();
                 stmt.setCompress(Boolean.FALSE);
@@ -117,6 +130,92 @@ public class OracleCreateTableParser extends SQLCreateTableParser {
                 lexer.nextToken();
                 stmt.setMaxtrans(this.exprParser.expr());
                 continue;
+            } else if (identifierEquals("PARTITION")) {
+                lexer.nextToken();
+                accept(Token.BY);
+
+                if (identifierEquals("RANGE")) {
+                    lexer.nextToken();
+                    accept(Token.LPAREN);
+                    OraclePartitionByRangeClause clause = new OraclePartitionByRangeClause();
+                    for (;;) {
+                        SQLName column = this.exprParser.name();
+                        clause.getColumns().add(column);
+                        
+                        if (lexer.token() == Token.COMMA) {
+                            lexer.nextToken();
+                            continue;
+                        }
+                        
+                        break;
+                    }
+                    accept(Token.RPAREN);
+                    
+                    if (identifierEquals("INTERVAL")) {
+                        lexer.nextToken();
+                        clause.setInterval(this.exprParser.expr());
+                    }
+                    
+                    if (identifierEquals("STORE")) {
+                        lexer.nextToken();
+                        accept(Token.IN);
+                        accept(Token.LPAREN);
+                        for (;;) {
+                            SQLName tablespace = this.exprParser.name();
+                            clause.getStoreIn().add(tablespace);
+                            
+                            if (lexer.token() == Token.COMMA) {
+                                lexer.nextToken();
+                                continue;
+                            }
+                            
+                            break;
+                        }
+                        accept(Token.RPAREN);
+                    }
+                    
+                    accept(Token.LPAREN);
+                    
+                    for (;;) {
+                        acceptIdentifier("PARTITION");
+                        OracleRangeValuesClause range = new OracleRangeValuesClause();
+                        range.setName(this.exprParser.name());
+                        
+                        accept(Token.VALUES);
+                        acceptIdentifier("LESS");
+                        acceptIdentifier("THAN");
+                        
+                        accept(Token.LPAREN);
+                        for (;;) {
+                            SQLExpr rangeValue = this.exprParser.expr();
+                            range.getValues().add(rangeValue);
+                            
+                            if (lexer.token() == Token.COMMA) {
+                                lexer.nextToken();
+                                continue;
+                            }
+                            
+                            break;
+                        }
+                        accept(Token.RPAREN);
+                        
+                        clause.getRanges().add(range);
+                        
+                        if (lexer.token() == Token.COMMA) {
+                            lexer.nextToken();
+                            continue;
+                        }
+                        
+                        break;
+                    }
+                    
+                    accept(Token.RPAREN);
+                    
+                    stmt.setPartitioning(clause);
+                    continue;
+                } else {
+                    throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                }
             }
             break;
         }

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

@@ -28,6 +28,7 @@ import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr;
 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.SQLNumericLiteralExpr;
 import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
 import com.alibaba.druid.sql.ast.expr.SQLUnaryExpr;
 import com.alibaba.druid.sql.ast.expr.SQLUnaryOperator;
@@ -73,6 +74,8 @@ public class OracleExprParser extends SQLExprParser {
 
 
 
+
+
     public boolean                allowStringAdditive = false;
 
     /**
@@ -274,7 +277,7 @@ public class OracleExprParser extends SQLExprParser {
     }
 
     public SQLExpr primaryRest(SQLExpr expr) throws ParserException {
-        if (lexer.token() == Token.IDENTIFIER) {
+        if (lexer.token() == Token.IDENTIFIER && expr instanceof SQLNumericLiteralExpr) {
             String ident = lexer.stringVal();
             if (ident.length() == 1) {
                 char unit = ident.charAt(0);
@@ -313,9 +316,14 @@ public class OracleExprParser extends SQLExprParser {
             OracleDbLinkExpr dblink = new OracleDbLinkExpr();
             dblink.setExpr(expr);
 
-            String link = lexer.stringVal();
-            accept(Token.IDENTIFIER);
-            dblink.setDbLink(link);
+            if (lexer.token() == Token.BANG) {
+                dblink.setDbLink("!");
+                lexer.nextToken();
+            } else {
+                String link = lexer.stringVal();
+                accept(Token.IDENTIFIER);
+                dblink.setDbLink(link);
+            }
 
             expr = dblink;
         }

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

@@ -10,6 +10,8 @@ import com.alibaba.druid.sql.parser.Lexer;
 import com.alibaba.druid.sql.parser.SQLParseException;
 import com.alibaba.druid.sql.parser.Token;
 
+import static com.alibaba.druid.sql.parser.LayoutCharacters.EOI;
+
 public class OracleLexer extends Lexer {
 
     public final static Keywords DEFAULT_ORACLE_KEYWORDS;
@@ -271,6 +273,8 @@ public class OracleLexer extends Lexer {
                     }
                     sp++;
                     break;
+                } else if (ch == EOI) {
+                    break;
                 }
 
                 if (ch == '\r') {

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

@@ -61,8 +61,10 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterViewStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateSequenceStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExplainStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleFileSpecification;
@@ -74,6 +76,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLabelStatement;
 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.OracleLoopStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OraclePLSQLCommitStatement;
@@ -237,6 +240,17 @@ public class OracleStatementParser extends SQLStatementParser {
                 statementList.add(this.parseException());
                 continue;
             }
+            
+            if (identifierEquals("EXIT")) {
+                lexer.nextToken();
+                OracleExitStatement stmt = new OracleExitStatement();
+                if (lexer.token() == Token.WHEN) {
+                    lexer.nextToken();
+                    stmt.setWhen(this.exprParser.expr());
+                }
+                statementList.add(stmt);
+                continue;
+            }
 
             if (lexer.token() == Token.IDENTIFIER) {
                 if (identifierEquals("EXPLAIN")) {
@@ -281,6 +295,10 @@ public class OracleStatementParser extends SQLStatementParser {
                 statementList.add(this.parseFor());
                 continue;
             }
+            if (lexer.token() == Token.LOOP) {
+                statementList.add(this.parseLoop());
+                continue;
+            }
             if (lexer.token() == Token.IF) {
                 statementList.add(this.parseIf());
                 continue;
@@ -313,7 +331,7 @@ public class OracleStatementParser extends SQLStatementParser {
                 statementList.add(stmt);
                 continue;
             }
-
+            
             throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
         }
     }
@@ -372,6 +390,17 @@ public class OracleStatementParser extends SQLStatementParser {
         accept(Token.LOOP);
         return stmt;
     }
+    
+    public OracleLoopStatement parseLoop() {
+        accept(Token.LOOP);
+        
+        OracleLoopStatement stmt = new OracleLoopStatement();
+        
+        this.parseStatementList(stmt.getStatements());
+        accept(Token.END);
+        accept(Token.LOOP);
+        return stmt;
+    }
 
     public SQLStatement parseGrant() {
         accept(Token.GRANT);
@@ -1362,4 +1391,47 @@ public class OracleStatementParser extends SQLStatementParser {
         return stmt;
     }
 
+    public OracleCreateSequenceStatement parseCreateSequence(boolean acceptCreate) {
+        if (acceptCreate) {
+            accept(Token.CREATE);
+        }
+        
+        acceptIdentifier("SEQUENCE");
+
+        OracleCreateSequenceStatement stmt = new OracleCreateSequenceStatement();
+        stmt.setName(this.exprParser.name());
+        
+        for (;;) {
+            if (lexer.token() == Token.START) {
+                lexer.nextToken();
+                accept(Token.WITH);
+                stmt.setStartWith(this.exprParser.expr());
+                continue;
+            } else if (identifierEquals("INCREMENT")) {
+                lexer.nextToken();
+                accept(Token.BY);
+                stmt.setIncrementBy(this.exprParser.expr());
+                continue;
+            } else if (identifierEquals("CACHE")) {
+                lexer.nextToken();
+                stmt.setCache(Boolean.TRUE);
+                continue;
+            } else if (identifierEquals("NOCACHE")) {
+                lexer.nextToken();
+                stmt.setCache(Boolean.FALSE);
+                continue;
+            } else if (identifierEquals("CYCLE")) {
+                lexer.nextToken();
+                stmt.setCycle(Boolean.TRUE);
+                continue;
+            } else if (identifierEquals("NOCYCLE")) {
+                lexer.nextToken();
+                stmt.setCycle(Boolean.FALSE);
+                continue;
+            } 
+            break;
+        }
+
+        return stmt;
+    }
 }

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

@@ -19,11 +19,13 @@ import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause.QueryPartitio
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause.ReturnRowsClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleErrorLoggingClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleParameter;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OraclePartitionByRangeClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleRangeValuesClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleStorageClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SampleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SearchClause;
-import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleStorageClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause.Entry;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAggregateExpr;
@@ -65,9 +67,11 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateSequenceStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExplainStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleFileSpecification;
@@ -80,6 +84,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement.ElseIf;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLabelStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLoopStatement;
 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;
@@ -1303,4 +1308,53 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora
         
     }
 
+    @Override
+    public boolean visit(OracleCreateSequenceStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleCreateSequenceStatement x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleRangeValuesClause x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleRangeValuesClause x) {
+        
+    }
+
+    @Override
+    public boolean visit(OraclePartitionByRangeClause x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OraclePartitionByRangeClause x) {
+        
+    }
+    @Override
+    public boolean visit(OracleLoopStatement x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleLoopStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleExitStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleExitStatement x) {
+        
+    }
+
 }

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

@@ -26,11 +26,13 @@ import com.alibaba.druid.sql.dialect.oracle.ast.clause.GroupingSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleErrorLoggingClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleParameter;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OraclePartitionByRangeClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleRangeValuesClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleStorageClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SampleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SearchClause;
-import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleStorageClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAggregateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAnalytic;
@@ -71,9 +73,11 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateSequenceStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExplainStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleFileSpecification;
@@ -86,6 +90,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement.ElseIf;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLabelStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLoopStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.ConditionalInsertClause;
@@ -575,4 +580,24 @@ public interface OracleASTVisitor extends SQLASTVisitor {
     boolean visit(OracleTruncateStatement x);
     
     void endVisit(OracleTruncateStatement x);
+    
+    boolean visit(OracleCreateSequenceStatement x);
+    
+    void endVisit(OracleCreateSequenceStatement x);
+    
+    boolean visit(OracleRangeValuesClause x);
+    
+    void endVisit(OracleRangeValuesClause x);
+    
+    boolean visit(OraclePartitionByRangeClause x);
+    
+    void endVisit(OraclePartitionByRangeClause x);
+    
+    boolean visit(OracleLoopStatement x);
+    
+    void endVisit(OracleLoopStatement x);
+    
+    boolean visit(OracleExitStatement x);
+    
+    void endVisit(OracleExitStatement x);
 }

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

@@ -34,7 +34,6 @@ import com.alibaba.druid.sql.ast.statement.SQLInsertStatement;
 import com.alibaba.druid.sql.ast.statement.SQLJoinTableSource.JoinType;
 import com.alibaba.druid.sql.ast.statement.SQLSelect;
 import com.alibaba.druid.sql.ast.statement.SQLSelectQueryBlock;
-import com.alibaba.druid.sql.ast.statement.SQLTruncateStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleHint;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleOrderBy;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.CycleClause;
@@ -56,11 +55,13 @@ import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause.ReferenceMode
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause.ReturnRowsClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleErrorLoggingClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleParameter;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OraclePartitionByRangeClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleRangeValuesClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleStorageClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SampleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SearchClause;
-import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleStorageClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAggregateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAnalytic;
@@ -106,9 +107,11 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateSequenceStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExplainStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleFileSpecification;
@@ -121,6 +124,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement.ElseIf;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLabelStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLoopStatement;
 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;
@@ -1928,7 +1932,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public boolean visit(OracleExplainStatement x) {
-        print("XPLAIN PLAN");
+        print("EXPLAIN PLAN");
         incrementIndent();
         println();
         if (x.getStatementId() != null) {
@@ -2430,6 +2434,12 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
             print(" NOPARALLEL");
         }
         
+        if (x.getCache() == Boolean.TRUE) {
+            print(" CACHE");
+        } else if (x.getCache() == Boolean.FALSE) {
+            print(" NOCACHE");
+        }
+        
         if (x.getCompress() == Boolean.TRUE) {
             print(" COMPRESS");
         } else if (x.getCompress() == Boolean.FALSE) {
@@ -2454,6 +2464,11 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
         if (x.isPreserveRows()) {
             print(" PRESERVE ROWS");
         }
+        
+        if (x.getPartitioning() != null) {
+            println();
+            x.getPartitioning().accept(this);
+        }
 
         if (x.getSelect() != null) {
             println();
@@ -2751,4 +2766,143 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
     public void endVisit(OracleTruncateStatement x) {
         
     }
+
+    @Override
+    public boolean visit(OracleCreateSequenceStatement x) {
+        print("CREATE SEQUENCE ");
+        x.getName().accept(this);
+        
+        if (x.getStartWith() != null) {
+            print(" START WITH ");
+            x.getStartWith().accept(this);
+        }
+        
+        if (x.getIncrementBy() != null) {
+            print(" INCREMENT BY ");
+            x.getIncrementBy().accept(this);
+        }
+        
+        if (x.getMaxValue() != null) {
+            print(" MAXVALUE ");
+            x.getMaxValue().accept(this);
+        }
+        
+        if (x.getCycle() != null) {
+            if (x.getCycle().booleanValue()) {
+                print(" CYCLE");
+            } else {
+                print(" NOCYCLE");
+            }
+        }
+        
+        if (x.getCache() != null) {
+            if (x.getCache().booleanValue()) {
+                print(" CACHE");
+            } else {
+                print(" NOCACHE");
+            }
+        }
+        
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleCreateSequenceStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleRangeValuesClause x) {
+        print("PARTITION ");
+        x.getName().accept(this);
+        print(" VALUES LESS THAN (");
+        printAndAccept(x.getValues(), ", ");
+        print(")");
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleRangeValuesClause x) {
+        
+    }
+
+    @Override
+    public boolean visit(OraclePartitionByRangeClause x) {
+        print("PARTITION BY RANGE (");
+        printAndAccept(x.getColumns(), ", ");
+        print(")");
+        
+        if (x.getInterval() != null) {
+            print(" INTERVAL ");
+            x.getInterval().accept(this);
+        }
+        
+        if (x.getStoreIn().size() > 0) {
+            print(" STORE IN (");
+            printAndAccept(x.getStoreIn(), ", ");
+            print(")");
+        }
+        
+
+        println();
+        print("(");
+        incrementIndent();
+        for (int i = 0, size = x.getRanges().size(); i < size; ++i) {
+            if (i != 0) {
+                print(",");
+            }
+            println();
+            x.getRanges().get(i).accept(this);
+        }
+        decrementIndent();
+        println();
+        print(")");
+        return false;
+    }
+
+    @Override
+    public void endVisit(OraclePartitionByRangeClause x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleLoopStatement x) {
+        print("LOOP");
+        incrementIndent();
+        println();
+
+        for (int i = 0, size = x.getStatements().size(); i < size; ++i) {
+            SQLStatement item = x.getStatements().get(i);
+            item.setParent(x);
+            item.accept(this);
+            if (i != size - 1) {
+                println();
+            }
+        }
+
+        decrementIndent();
+        println();
+        print("END LOOP");
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleLoopStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleExitStatement x) {
+        print("EXIT");
+        if (x.getWhen() != null) {
+            print(" WHEN ");
+            x.getWhen().accept(this);
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleExitStatement x) {
+        
+    }
 }

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

@@ -38,6 +38,8 @@ import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause.QueryPartitio
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause.ReturnRowsClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleErrorLoggingClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleParameter;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OraclePartitionByRangeClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleRangeValuesClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SampleClause;
@@ -84,9 +86,11 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateSequenceStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExplainStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleFileSpecification;
@@ -99,6 +103,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement.ElseIf;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLabelStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLoopStatement;
 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;
@@ -1652,15 +1657,15 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
     public void endVisit(AsOfSnapshotClause x) {
 
     }
-    
+
     @Override
     public boolean visit(OracleAlterViewStatement x) {
         return false;
     }
-    
+
     @Override
     public void endVisit(OracleAlterViewStatement x) {
-        
+
     }
 
     @Override
@@ -1670,7 +1675,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleAlterTableMoveTablespace x) {
-        
+
     }
 
     @Override
@@ -1680,16 +1685,17 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleSizeExpr x) {
-        
+
     }
+
     @Override
     public boolean visit(OracleFileSpecification x) {
         return false;
     }
-    
+
     @Override
     public void endVisit(OracleFileSpecification x) {
-        
+
     }
 
     @Override
@@ -1699,7 +1705,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleAlterTablespaceAddDataFile x) {
-        
+
     }
 
     @Override
@@ -1709,7 +1715,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleAlterTablespaceStatement x) {
-        
+
     }
 
     @Override
@@ -1719,6 +1725,56 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleTruncateStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleCreateSequenceStatement x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleCreateSequenceStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleRangeValuesClause x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleRangeValuesClause x) {
+
+    }
+
+    @Override
+    public boolean visit(OraclePartitionByRangeClause x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OraclePartitionByRangeClause x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleLoopStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleLoopStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleExitStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleExitStatement x) {
         
     }
 }

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

@@ -59,7 +59,6 @@ import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 import com.alibaba.druid.sql.ast.statement.SQLPrimaryKey;
 import com.alibaba.druid.sql.ast.statement.SQLSelect;
 import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
-import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OraclePrimaryKey;
 
 public class SQLExprParser extends SQLParser {
 

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

@@ -95,7 +95,7 @@ public class SQLParser {
             lexer.nextToken();
         } else if (lexer.token() == Token.YEAR || lexer.token() == Token.DAY || lexer.token() == Token.TIME
                    || lexer.token() == Token.MONTH || lexer.token() == Token.CASE || lexer.token() == Token.AT
-                   || lexer.token() == Token.TIMESTAMP) {
+                   || lexer.token() == Token.TIMESTAMP || lexer.token() == Token.LOG) {
             alias = lexer.token.name();
             lexer.nextToken();
         }

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

@@ -202,6 +202,10 @@ public class SQLStatementParser extends SQLParser {
         SQLName tableName = this.exprParser.name();
         insertStatement.setTableName(tableName);
         
+        if (lexer.token() == Token.LITERAL_ALIAS) {
+            insertStatement.setAlias(as());
+        }
+        
         parseInsert0_hinits(insertStatement);
         
         if (lexer.token() == Token.IDENTIFIER) {
@@ -288,11 +292,17 @@ public class SQLStatementParser extends SQLParser {
             return createTableParser.parseCrateTable(false);
         } else if (token == Token.INDEX || token == Token.UNIQUE) {
             return parseCreateIndex(false);
+        } else if (identifierEquals("SEQUENCE")) {
+            return parseCreateSequence(false);
         }
 
         throw new ParserException("TODO " + lexer.token());
     }
     
+    public SQLStatement parseCreateSequence(boolean acceptCreate) {
+        throw new ParserException("TODO " + lexer.token());
+    }
+    
     public SQLStatement parseCreateIndex(boolean acceptCreate) {
         throw new ParserException("TODO " + lexer.token());
     }

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

@@ -66,32 +66,32 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
     public final static String                         ATTR_COLUMN    = "_column_";
 
     private Mode                                       mode;
-    
+
     public TableStat getTableStat(String ident) {
         return getTableStat(ident, null);
     }
-    
+
     public Column addColumn(String tableName, String columnName) {
         tableName = handleName(tableName);
         columnName = handleName(columnName);
-        
+
         Column column = new Column(tableName, columnName);
         columns.add(column);
         return column;
     }
 
     public TableStat getTableStat(String tableName, String alias) {
-        if (variants.containsKey(tableName)){
+        if (variants.containsKey(tableName)) {
             return null;
         }
-        
+
         tableName = handleName(tableName);
         TableStat stat = tableStats.get(tableName);
         if (stat == null) {
             stat = new TableStat();
             tableStats.put(new TableStat.Name(tableName), stat);
             if (alias != null) {
-                aliasMap.put(alias, tableName);    
+                aliasMap.put(alias, tableName);
             }
         }
         return stat;
@@ -100,9 +100,9 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
     private String handleName(String ident) {
         ident = ident.replaceAll("\"", "");
         ident = ident.replaceAll(" ", "");
-        
+
         ident = aliasWrap(ident);
-        
+
         return ident;
     }
 
@@ -323,6 +323,10 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
                     table = aliasMap.get(table);
                 }
 
+                if (variants.containsKey(table)) {
+                    return null;
+                }
+
                 if (table != null) {
                     return new Column(table, column);
                 }
@@ -353,6 +357,10 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
             if (table != null) {
                 return new Column(table, column);
             }
+            
+            if (variants.containsKey(column)) {
+                return null;
+            }
 
             return new Column("UNKNOWN", column);
         }
@@ -524,8 +532,16 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
 
     protected String aliasWrap(String name) {
         Map<String, String> aliasMap = getAliasMap();
-        if (aliasMap.containsKey(name)) {
-            return aliasMap.get(name);
+
+        if (aliasMap != null) {
+            for (Map.Entry<String, String> entry : aliasMap.entrySet()) {
+                if (entry.getKey() == null) {
+                    continue;
+                }
+                if (entry.getKey().equalsIgnoreCase(name)) {
+                    return entry.getValue();
+                }
+            }
         }
 
         return name;
@@ -757,10 +773,14 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
 
         setMode(x, Mode.Delete);
 
-        String ident = x.getTableName().toString();
-        setCurrentTable(ident);
+        String tableName = x.getTableName().toString();
+        setCurrentTable(tableName);
 
-        TableStat stat = getTableStat(ident);
+        if (x.getAlias() != null) {
+            this.aliasMap.put(x.getAlias(), tableName);
+        }
+
+        TableStat stat = getTableStat(tableName);
         stat.incrementDeleteCount();
 
         accept(x.getWhere());
@@ -802,13 +822,13 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
         }
 
         String tableName = x.getName().toString();
-        
+
         TableStat stat = getTableStat(tableName);
         stat.incrementCreateCount();
         setCurrentTable(x, tableName);
 
         accept(x.getTableElementList());
-        
+
         restoreCurrentTable(x);
 
         return false;