bug fixed for oracle sql parser

src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlCreateTableParser.java

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.alibaba.druid.sql.dialect.mysql.ast.statement;
+package com.alibaba.druid.sql.dialect.mysql.parser;
 
 import com.alibaba.druid.sql.ast.SQLName;
 import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
@@ -22,7 +22,8 @@ import com.alibaba.druid.sql.ast.statement.SQLSelect;
 import com.alibaba.druid.sql.ast.statement.SQLTableConstaint;
 import com.alibaba.druid.sql.dialect.mysql.ast.MySqlKey;
 import com.alibaba.druid.sql.dialect.mysql.ast.MySqlPrimaryKey;
-import com.alibaba.druid.sql.dialect.mysql.parser.MySqlSelectParser;
+import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlCreateTableStatement;
+import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlTableIndex;
 import com.alibaba.druid.sql.parser.Lexer;
 import com.alibaba.druid.sql.parser.ParserException;
 import com.alibaba.druid.sql.parser.SQLCreateTableParser;
@@ -32,10 +33,12 @@ public class MySqlCreateTableParser extends SQLCreateTableParser {
 
     public MySqlCreateTableParser(String sql) throws ParserException{
         super(sql);
+        this.exprParser = new MySqlExprParser(lexer);
     }
 
     public MySqlCreateTableParser(Lexer lexer){
         super(lexer);
+        this.exprParser = new MySqlExprParser(lexer);
     }
 
     public SQLCreateTableStatement parseCrateTable() throws ParserException {
@@ -70,7 +73,7 @@ public class MySqlCreateTableParser extends SQLCreateTableParser {
 
             for (;;) {
                 if (lexer.token() == Token.IDENTIFIER) {
-                    SQLColumnDefinition column = parseColumn();
+                    SQLColumnDefinition column = this.exprParser.parseColumn();
                     createTable.getTableElementList().add(column);
                 } else if (lexer.token() == (Token.CONSTRAINT)) {
                     createTable.getTableElementList().add(parseConstraint());
@@ -149,28 +152,6 @@ public class MySqlCreateTableParser extends SQLCreateTableParser {
         return createTable;
     }
 
-    protected SQLColumnDefinition parseColumn() throws ParserException {
-        MySqlSQLColumnDefinition column = new MySqlSQLColumnDefinition();
-        column.setName(this.exprParser.name());
-        column.setDataType(this.exprParser.parseDataType());
-
-        return parseColumnRest(column);
-    }
-
-    protected SQLColumnDefinition parseColumnRest(SQLColumnDefinition column) throws ParserException {
-        if (identifierEquals("AUTO_INCREMENT")) {
-            lexer.nextToken();
-            if (column instanceof MySqlSQLColumnDefinition) {
-                ((MySqlSQLColumnDefinition) column).setAutoIncrement(true);
-            }
-            return parseColumnRest(column);
-        }
-
-        super.parseColumnRest(column);
-
-        return column;
-    }
-
     @SuppressWarnings("unused")
     protected SQLTableConstaint parseConstraint() throws ParserException {
         SQLName name = null;

src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlExprParser.java

@@ -24,6 +24,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.SQLVariantRefExpr;
+import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 import com.alibaba.druid.sql.dialect.mysql.ast.expr.MySqlBinaryExpr;
 import com.alibaba.druid.sql.dialect.mysql.ast.expr.MySqlBooleanExpr;
 import com.alibaba.druid.sql.dialect.mysql.ast.expr.MySqlCharExpr;
@@ -32,6 +33,7 @@ import com.alibaba.druid.sql.dialect.mysql.ast.expr.MySqlIntervalExpr;
 import com.alibaba.druid.sql.dialect.mysql.ast.expr.MySqlIntervalUnit;
 import com.alibaba.druid.sql.dialect.mysql.ast.expr.MySqlMatchAgainstExpr;
 import com.alibaba.druid.sql.dialect.mysql.ast.expr.MySqlMatchAgainstExpr.SearchModifier;
+import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlSQLColumnDefinition;
 import com.alibaba.druid.sql.parser.Lexer;
 import com.alibaba.druid.sql.parser.ParserException;
 import com.alibaba.druid.sql.parser.SQLExprParser;
@@ -420,4 +422,26 @@ public class MySqlExprParser extends SQLExprParser {
             return intervalExpr;
         }
     }
+    
+    public SQLColumnDefinition parseColumn() throws ParserException {
+        MySqlSQLColumnDefinition column = new MySqlSQLColumnDefinition();
+        column.setName(name());
+        column.setDataType(parseDataType());
+
+        return parseColumnRest(column);
+    }
+
+    public SQLColumnDefinition parseColumnRest(SQLColumnDefinition column) throws ParserException {
+        if (identifierEquals("AUTO_INCREMENT")) {
+            lexer.nextToken();
+            if (column instanceof MySqlSQLColumnDefinition) {
+                ((MySqlSQLColumnDefinition) column).setAutoIncrement(true);
+            }
+            return parseColumnRest(column);
+        }
+
+        super.parseColumnRest(column);
+
+        return column;
+    }
 }

src/main/java/com/alibaba/druid/sql/dialect/mysql/parser/MySqlStatementParser.java

@@ -34,7 +34,6 @@ import com.alibaba.druid.sql.ast.statement.SQLUpdateSetItem;
 import com.alibaba.druid.sql.dialect.mysql.ast.statement.CobarShowStatus;
 import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlBinlogStatement;
 import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlCommitStatement;
-import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlCreateTableParser;
 import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlCreateUserStatement;
 import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlDeleteStatement;
 import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlDropUser;

src/main/java/com/alibaba/druid/sql/dialect/oracle/ast/expr/OracleRangeExpr.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 OracleRangeExpr extends OracleSQLObjectImpl implements SQLExpr {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLExpr           lowBound;
+    private SQLExpr           upBound;
+
+    public OracleRangeExpr(){
+
+    }
+
+    public OracleRangeExpr(SQLExpr lowBound, SQLExpr upBound){
+        this.lowBound = lowBound;
+        this.upBound = upBound;
+    }
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, lowBound);
+            acceptChild(visitor, upBound);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLExpr getLowBound() {
+        return lowBound;
+    }
+
+    public void setLowBound(SQLExpr lowBound) {
+        this.lowBound = lowBound;
+    }
+
+    public SQLExpr getUpBound() {
+        return upBound;
+    }
+
+    public void setUpBound(SQLExpr upBound) {
+        this.upBound = upBound;
+    }
+
+}

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

@@ -0,0 +1,93 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.ast.SQLObject;
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleAlterIndexStatement extends OracleStatementImpl {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLName           name;
+
+    private boolean           compile;
+
+    private Boolean           enable;
+
+    private Boolean           monitoringUsage;
+
+    private Rebuild           rebuild;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+            acceptChild(visitor, rebuild);
+        }
+        visitor.endVisit(this);
+    }
+
+    public Boolean getMonitoringUsage() {
+        return monitoringUsage;
+    }
+
+    public void setMonitoringUsage(Boolean monitoringUsage) {
+        this.monitoringUsage = monitoringUsage;
+    }
+
+    public Rebuild getRebuild() {
+        return rebuild;
+    }
+
+    public void setRebuild(Rebuild rebuild) {
+        this.rebuild = rebuild;
+    }
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+    public boolean isCompile() {
+        return compile;
+    }
+
+    public void setCompile(boolean compile) {
+        this.compile = compile;
+    }
+
+    public Boolean getEnable() {
+        return enable;
+    }
+
+    public void setEnable(Boolean enable) {
+        this.enable = enable;
+    }
+
+    public static class Rebuild extends OracleSQLObjectImpl {
+
+        private static final long serialVersionUID = 1L;
+        private SQLObject         option;
+
+        public SQLObject getOption() {
+            return option;
+        }
+
+        public void setOption(SQLObject option) {
+            this.option = option;
+        }
+
+        @Override
+        public void accept0(OracleASTVisitor visitor) {
+            if (visitor.visit(this)) {
+                acceptChild(visitor, option);
+            }
+            visitor.endVisit(this);
+        }
+
+    }
+}

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

@@ -0,0 +1,47 @@
+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 OracleAlterProcedureStatement extends OracleStatementImpl {
+
+    private SQLExpr           name;
+
+    private boolean           compile          = false;
+    private boolean           reuseSettings    = false;
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLExpr getName() {
+        return name;
+    }
+
+    public void setName(SQLExpr name) {
+        this.name = name;
+    }
+
+    public boolean isCompile() {
+        return compile;
+    }
+
+    public void setCompile(boolean compile) {
+        this.compile = compile;
+    }
+
+    public boolean isReuseSettings() {
+        return reuseSettings;
+    }
+
+    public void setReuseSettings(boolean reuseSettings) {
+        this.reuseSettings = reuseSettings;
+    }
+
+}

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

@@ -0,0 +1,28 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleAlterTableAddColumn extends OracleAlterTableItem {
+
+    private static final long   serialVersionUID = 1L;
+
+    private SQLColumnDefinition column;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, column);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLColumnDefinition getColumn() {
+        return column;
+    }
+
+    public void setColumn(SQLColumnDefinition column) {
+        this.column = column;
+    }
+
+}

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

@@ -0,0 +1,28 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleAlterTableDropPartition extends OracleAlterTableItem {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLName           name;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+}

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

@@ -0,0 +1,9 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
+
+public abstract class OracleAlterTableItem extends OracleSQLObjectImpl {
+
+    private static final long serialVersionUID = 1L;
+
+}

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

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

@@ -0,0 +1,161 @@
+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.SQLObject;
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleAlterTableSplitPartition extends OracleAlterTableItem {
+
+    private static final long              serialVersionUID = 1L;
+
+    private SQLName                        name;
+    private List<SQLExpr>                  at               = new ArrayList<SQLExpr>();
+    private List<SQLExpr>                  values           = new ArrayList<SQLExpr>();
+    private List<NestedTablePartitionSpec> into             = new ArrayList<NestedTablePartitionSpec>();
+
+    private UpdateIndexesClause            updateIndexes    = null;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+            acceptChild(visitor, at);
+            acceptChild(visitor, values);
+            acceptChild(visitor, updateIndexes);
+        }
+        visitor.endVisit(this);
+    }
+
+    public UpdateIndexesClause getUpdateIndexes() {
+        return updateIndexes;
+    }
+
+    public void setUpdateIndexes(UpdateIndexesClause updateIndexes) {
+        this.updateIndexes = updateIndexes;
+    }
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+    public List<SQLExpr> getAt() {
+        return at;
+    }
+
+    public void setAt(List<SQLExpr> at) {
+        this.at = at;
+    }
+
+    public List<NestedTablePartitionSpec> getInto() {
+        return into;
+    }
+
+    public void setInto(List<NestedTablePartitionSpec> into) {
+        this.into = into;
+    }
+
+    public List<SQLExpr> getValues() {
+        return values;
+    }
+
+    public void setValues(List<SQLExpr> values) {
+        this.values = values;
+    }
+
+    public static class NestedTablePartitionSpec extends OracleSQLObjectImpl {
+
+        private static final long serialVersionUID      = 1L;
+
+        private SQLName           partition;
+
+        private List<SQLObject>   segmentAttributeItems = new ArrayList<SQLObject>();
+
+        @Override
+        public void accept0(OracleASTVisitor visitor) {
+            if (visitor.visit(this)) {
+                acceptChild(visitor, partition);
+                acceptChild(visitor, segmentAttributeItems);
+            }
+            visitor.endVisit(this);
+        }
+
+        public SQLName getPartition() {
+            return partition;
+        }
+
+        public void setPartition(SQLName partition) {
+            this.partition = partition;
+        }
+
+        public List<SQLObject> getSegmentAttributeItems() {
+            return segmentAttributeItems;
+        }
+
+        public void setSegmentAttributeItems(List<SQLObject> segmentAttributeItems) {
+            this.segmentAttributeItems = segmentAttributeItems;
+        }
+
+    }
+
+    public static class TableSpaceItem extends OracleSQLObjectImpl {
+
+        private static final long serialVersionUID = 1L;
+        private SQLName           tablespace;
+
+        public TableSpaceItem(){
+
+        }
+
+        public TableSpaceItem(SQLName tablespace){
+            this.tablespace = tablespace;
+        }
+
+        @Override
+        public void accept0(OracleASTVisitor visitor) {
+            if (visitor.visit(this)) {
+                acceptChild(visitor, tablespace);
+            }
+            visitor.endVisit(this);
+        }
+
+        public SQLName getTablespace() {
+            return tablespace;
+        }
+
+        public void setTablespace(SQLName tablespace) {
+            this.tablespace = tablespace;
+        }
+    }
+
+    public static class UpdateIndexesClause extends OracleSQLObjectImpl {
+
+        private static final long serialVersionUID = 1L;
+        private List<SQLObject>   items            = new ArrayList<SQLObject>();
+
+        @Override
+        public void accept0(OracleASTVisitor visitor) {
+            if (visitor.visit(this)) {
+                acceptChild(visitor, items);
+            }
+            visitor.endVisit(this);
+        }
+
+        public List<SQLObject> getItems() {
+            return items;
+        }
+
+        public void setItems(List<SQLObject> items) {
+            this.items = items;
+        }
+
+    }
+}

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

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

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

@@ -0,0 +1,28 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleAlterTableTruncatePartition extends OracleAlterTableItem {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLName           name;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+}

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

@@ -4,13 +4,16 @@ import java.util.ArrayList;
 import java.util.List;
 
 import com.alibaba.druid.sql.ast.SQLStatement;
+import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
 
 public class OracleBlockStatement extends OracleStatementImpl {
 
-    private static final long  serialVersionUID = 1L;
+    private static final long         serialVersionUID = 1L;
 
-    private List<SQLStatement> statementList    = new ArrayList<SQLStatement>();
+    private List<SQLColumnDefinition> parameters       = new ArrayList<SQLColumnDefinition>();
+
+    private List<SQLStatement>        statementList    = new ArrayList<SQLStatement>();
 
     public List<SQLStatement> getStatementList() {
         return statementList;
@@ -23,9 +26,18 @@ public class OracleBlockStatement extends OracleStatementImpl {
     @Override
     public void accept0(OracleASTVisitor visitor) {
         if (visitor.visit(this)) {
+            acceptChild(visitor, parameters);
             acceptChild(visitor, statementList);
         }
         visitor.endVisit(this);
     }
 
+    public List<SQLColumnDefinition> getParameters() {
+        return parameters;
+    }
+
+    public void setParameters(List<SQLColumnDefinition> parameters) {
+        this.parameters = parameters;
+    }
+
 }

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

@@ -0,0 +1,89 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleCreateIndexStatement extends OracleStatementImpl {
+
+    private static final long          serialVersionUID = 1L;
+
+    private SQLName                    name;
+
+    private SQLName                    table;
+
+    private List<SQLSelectOrderByItem> items            = new ArrayList<SQLSelectOrderByItem>();
+
+    private SQLName                    tablespace;
+
+    private Type                       type;
+
+    private boolean                    online           = false;
+
+    public Type getType() {
+        return type;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+            acceptChild(visitor, table);
+            acceptChild(visitor, items);
+            acceptChild(visitor, tablespace);
+        }
+        visitor.endVisit(this);
+    }
+
+    public static enum Type {
+        UNIQUE, BITMAP
+    }
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+    public SQLName getTable() {
+        return table;
+    }
+
+    public void setTable(SQLName table) {
+        this.table = table;
+    }
+
+    public List<SQLSelectOrderByItem> getItems() {
+        return items;
+    }
+
+    public void setItems(List<SQLSelectOrderByItem> items) {
+        this.items = items;
+    }
+
+    public SQLName getTablespace() {
+        return tablespace;
+    }
+
+    public void setTablespace(SQLName tablespace) {
+        this.tablespace = tablespace;
+    }
+
+    public boolean isOnline() {
+        return online;
+    }
+
+    public void setOnline(boolean online) {
+        this.online = online;
+    }
+
+}

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

@@ -0,0 +1,20 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
+
+public class OracleCreateTableStatement extends SQLCreateTableStatement {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLName           tablespace;
+
+    public SQLName getTablespace() {
+        return tablespace;
+    }
+
+    public void setTablespace(SQLName tablespace) {
+        this.tablespace = tablespace;
+    }
+
+}

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

@@ -20,6 +20,7 @@ import java.util.List;
 
 import com.alibaba.druid.sql.ast.statement.SQLDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleHint;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
 import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
 import com.alibaba.druid.sql.visitor.SQLASTVisitor;
 
@@ -30,11 +31,20 @@ public class OracleDeleteStatement extends SQLDeleteStatement {
     private boolean                only             = false;
     private String                 alias;
     private final List<OracleHint> hints            = new ArrayList<OracleHint>();
+    private OracleReturningClause  returning        = null;
 
     public OracleDeleteStatement(){
 
     }
 
+    public OracleReturningClause getReturning() {
+        return returning;
+    }
+
+    public void setReturning(OracleReturningClause returning) {
+        this.returning = returning;
+    }
+
     public List<OracleHint> getHints() {
         return this.hints;
     }
@@ -48,6 +58,7 @@ public class OracleDeleteStatement extends SQLDeleteStatement {
             acceptChild(visitor, this.hints);
             acceptChild(visitor, this.getTableName());
             acceptChild(visitor, this.getWhere());
+            acceptChild(visitor, returning);
         }
 
         visitor.endVisit(this);

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

@@ -0,0 +1,50 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.SQLStatement;
+import com.alibaba.druid.sql.ast.expr.SQLCharExpr;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleExplainStatement extends OracleStatementImpl {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLCharExpr            statementId;
+    private SQLExpr           into;
+    private SQLStatement      forStatement;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, statementId);
+            acceptChild(visitor, into);
+            acceptChild(visitor, forStatement);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLCharExpr getStatementId() {
+        return statementId;
+    }
+
+    public void setStatementId(SQLCharExpr statementId) {
+        this.statementId = statementId;
+    }
+
+    public SQLExpr getInto() {
+        return into;
+    }
+
+    public void setInto(SQLExpr into) {
+        this.into = into;
+    }
+
+    public SQLStatement getForStatement() {
+        return forStatement;
+    }
+
+    public void setForStatement(SQLStatement forStatement) {
+        this.forStatement = forStatement;
+    }
+
+}

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

@@ -1,19 +1,19 @@
 package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
 
-import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
+import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
 
-public class OracleMethodInvokeStatement extends OracleStatementImpl {
+public class OracleExprStatement extends OracleStatementImpl {
 
     private static final long   serialVersionUID = 1L;
 
-    private SQLMethodInvokeExpr expr;
+    private SQLExpr expr;
 
-    public OracleMethodInvokeStatement(){
+    public OracleExprStatement(){
 
     }
 
-    public OracleMethodInvokeStatement(SQLMethodInvokeExpr expr){
+    public OracleExprStatement(SQLExpr expr){
         this.expr = expr;
     }
 
@@ -26,11 +26,11 @@ public class OracleMethodInvokeStatement extends OracleStatementImpl {
 
     }
 
-    public SQLMethodInvokeExpr getExpr() {
+    public SQLExpr getExpr() {
         return expr;
     }
 
-    public void setExpr(SQLMethodInvokeExpr expr) {
+    public void setExpr(SQLExpr expr) {
         this.expr = expr;
     }
 

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

@@ -0,0 +1,55 @@
+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.SQLStatement;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleForStatement extends OracleStatementImpl {
+
+    private static final long  serialVersionUID = 1L;
+
+    private SQLName            index;
+
+    private SQLExpr            range;
+
+    private List<SQLStatement> statements       = new ArrayList<SQLStatement>();
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, index);
+            acceptChild(visitor, range);
+            acceptChild(visitor, statements);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLName getIndex() {
+        return index;
+    }
+
+    public void setIndex(SQLName index) {
+        this.index = index;
+    }
+
+    public SQLExpr getRange() {
+        return range;
+    }
+
+    public void setRange(SQLExpr range) {
+        this.range = range;
+    }
+
+    public List<SQLStatement> getStatements() {
+        return statements;
+    }
+
+    public void setStatements(List<SQLStatement> statements) {
+        this.statements = statements;
+    }
+
+}

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

@@ -0,0 +1,120 @@
+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.SQLStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleIfStatement extends OracleStatementImpl {
+
+    private static final long  serialVersionUID = 1L;
+
+    private SQLExpr            condition;
+    private List<SQLStatement> statements       = new ArrayList<SQLStatement>();
+    private List<ElseIf>       elseIfList       = new ArrayList<ElseIf>();
+    private Else               elseItem;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, condition);
+            acceptChild(visitor, statements);
+            acceptChild(visitor, elseIfList);
+            acceptChild(visitor, elseItem);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLExpr getCondition() {
+        return condition;
+    }
+
+    public void setCondition(SQLExpr condition) {
+        this.condition = condition;
+    }
+
+    public List<SQLStatement> getStatements() {
+        return statements;
+    }
+
+    public void setStatements(List<SQLStatement> statements) {
+        this.statements = statements;
+    }
+
+    public List<ElseIf> getElseIfList() {
+        return elseIfList;
+    }
+
+    public void setElseIfList(List<ElseIf> elseIfList) {
+        this.elseIfList = elseIfList;
+    }
+
+    public Else getElseItem() {
+        return elseItem;
+    }
+
+    public void setElseItem(Else elseItem) {
+        this.elseItem = elseItem;
+    }
+
+    public static class ElseIf extends OracleSQLObjectImpl {
+
+        private static final long  serialVersionUID = 1L;
+
+        private SQLExpr            condition;
+        private List<SQLStatement> statements       = new ArrayList<SQLStatement>();
+
+        @Override
+        public void accept0(OracleASTVisitor visitor) {
+            if (visitor.visit(this)) {
+                acceptChild(visitor, condition);
+                acceptChild(visitor, statements);
+            }
+            visitor.endVisit(this);
+        }
+
+        public SQLExpr getCondition() {
+            return condition;
+        }
+
+        public void setCondition(SQLExpr condition) {
+            this.condition = condition;
+        }
+
+        public List<SQLStatement> getStatements() {
+            return statements;
+        }
+
+        public void setStatements(List<SQLStatement> statements) {
+            this.statements = statements;
+        }
+
+    }
+
+    public static class Else extends OracleSQLObjectImpl {
+
+        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

@@ -0,0 +1,34 @@
+package com.alibaba.druid.sql.dialect.oracle.parser;
+
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
+import com.alibaba.druid.sql.parser.Lexer;
+import com.alibaba.druid.sql.parser.SQLCreateTableParser;
+
+public class OracleCreateTableParser extends SQLCreateTableParser {
+
+    public OracleCreateTableParser(Lexer lexer){
+        super(lexer);
+        this.exprParser = new OracleExprParser(lexer);
+    }
+
+    public OracleCreateTableParser(String sql){
+        super(new OracleLexer(sql));
+        this.lexer.nextToken();
+        this.exprParser = new OracleExprParser(lexer);
+    }
+
+    protected OracleCreateTableStatement newCreateStatement() {
+        return new OracleCreateTableStatement();
+    }
+    
+    public OracleCreateTableStatement parseCrateTable(boolean acceptCreate) {
+        OracleCreateTableStatement stmt = (OracleCreateTableStatement) super.parseCrateTable(acceptCreate);
+        
+        if (identifierEquals("TABLESPACE")) {
+            lexer.nextToken();
+            stmt.setTablespace(this.exprParser.name());
+        }
+        
+        return stmt;
+    }
+}

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

@@ -1,87 +0,0 @@
-/*
- * Copyright 1999-2011 Alibaba Group Holding Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.alibaba.druid.sql.dialect.oracle.parser;
-
-import com.alibaba.druid.sql.ast.SQLName;
-import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
-import com.alibaba.druid.sql.parser.Lexer;
-import com.alibaba.druid.sql.parser.ParserException;
-import com.alibaba.druid.sql.parser.SQLStatementParser;
-import com.alibaba.druid.sql.parser.Token;
-
-public class OracleDeleteParser extends SQLStatementParser {
-
-    public OracleDeleteParser(String sql){
-        super(sql);
-        this.exprParser = new OracleExprParser(lexer);
-    }
-
-    public OracleDeleteParser(Lexer lexer){
-        super(lexer);
-        this.exprParser = new OracleExprParser(lexer);
-    }
-    
-
-    public OracleDeleteStatement parseDelete() throws ParserException {
-        accept(Token.DELETE);
-
-        OracleDeleteStatement deleteStatement = new OracleDeleteStatement();
-
-        parseHints(deleteStatement);
-
-        if (lexer.token() == (Token.FROM)) {
-            lexer.nextToken();
-        }
-
-        if (identifierEquals("ONLY")) {
-            lexer.nextToken();
-            accept(Token.LPAREN);
-
-            SQLName tableName = exprParser.name();
-            deleteStatement.setTableName(tableName);
-
-            accept(Token.RPAREN);
-        } else {
-            SQLName tableName = exprParser.name();
-            deleteStatement.setTableName(tableName);
-        }
-
-        deleteStatement.setAlias(as());
-
-        if (lexer.token() == (Token.WHERE)) {
-            lexer.nextToken();
-            deleteStatement.setWhere(this.exprParser.expr());
-        }
-
-        if (identifierEquals("RETURN") || identifierEquals("RETURNING")) {
-            throw new ParserException("TODO");
-        }
-
-        if (identifierEquals("LOG")) {
-            throw new ParserException("TODO");
-        }
-
-        return deleteStatement;
-    }
-
-    protected OracleExprParser createExprParser() {
-        return new OracleExprParser(lexer);
-    }
-    
-    private void parseHints(OracleDeleteStatement parseInsert) throws ParserException {
-        this.createExprParser().parseHints(parseInsert.getHints());
-    }
-}

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

@@ -50,6 +50,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIntervalExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleIntervalType;
 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.OracleRangeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleSysdateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleOrderByItem;
@@ -250,6 +251,19 @@ public class OracleExprParser extends SQLExprParser {
                 return super.primary();
         }
     }
+    
+    @Override
+    protected SQLExpr methodRest(SQLExpr expr, boolean acceptLPAREN) {
+        if (acceptLPAREN) {
+            accept(Token.LPAREN);
+            if (lexer.token() == Token.PLUS) {
+                lexer.nextToken();
+                accept(Token.RPAREN);
+                return new OracleOuterExpr(expr);
+            }
+        }
+        return super.methodRest(expr, false);
+    }
 
     public SQLExpr primaryRest(SQLExpr expr) throws ParserException {
         if (lexer.token() == Token.MONKEYS_AT) {
@@ -355,6 +369,13 @@ public class OracleExprParser extends SQLExprParser {
     }
 
     protected SQLExpr dotRest(SQLExpr expr) {
+        if (lexer.token() == Token.DOT) {
+            lexer.nextToken();
+            SQLExpr upBound = expr();
+            
+            return new OracleRangeExpr(expr, upBound);
+        }
+        
         if (lexer.token() == Token.LITERAL_ALIAS) {
             String name = '"' + lexer.stringVal() + '"';
             lexer.nextToken();

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

@@ -122,6 +122,7 @@ public class OracleLexer extends Lexer {
         map.put("WAIT", Token.WAIT);
         map.put("NOWAIT", Token.NOWAIT);
         map.put("SESSION", Token.SESSION);
+        map.put("PROCEDURE", Token.PROCEDURE);
         map.put("AT", Token.AT);
         map.put("LOCAL", Token.LOCAL);
         map.put("TIME", Token.TIME);
@@ -131,6 +132,9 @@ public class OracleLexer extends Lexer {
         map.put("EXCEPTION", Token.EXCEPTION);
         map.put("GRANT", Token.GRANT);
         map.put("COMMENT", Token.COMMENT);
+        map.put("LOOP", Token.LOOP);
+        map.put("IF", Token.IF);
+        map.put("ELSE", Token.ELSE);
 
         DEFAULT_ORACLE_KEYWORDS = new Keywords(map);
     }
@@ -162,6 +166,13 @@ public class OracleLexer extends Lexer {
         sp = 1;
         char ch;
 
+        boolean quoteFlag = false;
+        if (buf[bp + 1] == '"') {
+            hash = 31 * hash + '"';
+            bp++;
+            sp++;
+            quoteFlag = true;
+        }
         for (;;) {
             ch = buf[++bp];
 
@@ -174,6 +185,14 @@ public class OracleLexer extends Lexer {
             sp++;
             continue;
         }
+        if (quoteFlag) {
+            if (ch != '"') {
+                throw new SQLParseException("syntax error");
+            }
+            hash = 31 * hash + '"';
+            ++bp;
+            sp++;
+        }
 
         this.ch = buf[bp];
 

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

@@ -919,8 +919,8 @@ public class OracleSelectParser extends SQLSelectParser {
                 this.createExprParser().exprList(join.getUsing());
                 accept(Token.RPAREN);
             }
-
-            return join;
+            
+            return parseTableSourceRest(join);
         }
 
         return tableSource;

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

@@ -23,9 +23,11 @@ import com.alibaba.druid.sql.ast.SQLName;
 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.expr.SQLCharExpr;
+import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 import com.alibaba.druid.sql.ast.statement.SQLInsertInto;
 import com.alibaba.druid.sql.ast.statement.SQLSelect;
+import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
 import com.alibaba.druid.sql.ast.statement.SQLSelectStatement;
 import com.alibaba.druid.sql.ast.statement.SQLSetStatement;
 import com.alibaba.druid.sql.ast.statement.SQLTableSource;
@@ -33,15 +35,31 @@ 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.OracleAlterIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableDropPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableModify;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.NestedTablePartitionSpec;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.TableSpaceItem;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.UpdateIndexesClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableTruncatePartition;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+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.OracleExplainStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement;
 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.OracleSetTransactionStatement;
@@ -68,6 +86,10 @@ public class OracleStatementParser extends SQLStatementParser {
         return new OracleExprParser(lexer);
     }
 
+    public OracleCreateTableParser getSQLCreateTableParser() {
+        return new OracleCreateTableParser(lexer);
+    }
+
     protected void parseInsert0_hinits(SQLInsertInto insertStatement) {
         if (insertStatement instanceof OracleInsertStatement) {
             OracleInsertStatement stmt = (OracleInsertStatement) insertStatement;
@@ -97,6 +119,9 @@ public class OracleStatementParser extends SQLStatementParser {
             if (lexer.token() == Token.END) {
                 return;
             }
+            if (lexer.token() == Token.ELSE) {
+                return;
+            }
 
             if (lexer.token() == (Token.SEMI)) {
                 lexer.nextToken();
@@ -114,9 +139,8 @@ public class OracleStatementParser extends SQLStatementParser {
             }
 
             if (lexer.token() == (Token.CREATE)) {
-                lexer.nextToken();
-
-                throw new ParserException("TODO");
+                statementList.add(parseCreate());
+                continue;
             }
 
             if (lexer.token() == Token.INSERT) {
@@ -125,7 +149,7 @@ public class OracleStatementParser extends SQLStatementParser {
             }
 
             if (lexer.token() == (Token.DELETE)) {
-                statementList.add(new OracleDeleteParser(this.lexer).parseDelete());
+                statementList.add(parseDelete());
                 continue;
             }
 
@@ -199,25 +223,29 @@ public class OracleStatementParser extends SQLStatementParser {
             }
 
             if (lexer.token() == Token.IDENTIFIER) {
-                SQLExpr expr = exprParser.expr();
-                if (expr instanceof SQLMethodInvokeExpr) {
-                    OracleMethodInvokeStatement stmt = new OracleMethodInvokeStatement((SQLMethodInvokeExpr) expr);
-                    statementList.add(stmt);
+                if (identifierEquals("EXPLAIN")) {
+                    statementList.add(this.parseExplain());
                     continue;
-                } else if (expr instanceof SQLName) {
-                    SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(((SQLName) expr).toString());
-                    statementList.add(new OracleMethodInvokeStatement(methodInvokeExpr));
-                    continue;
-                } else {
-                    throw new ParserException("expr : " + expr);
                 }
+
+                SQLExpr expr = exprParser.expr();
+                OracleExprStatement stmt = new OracleExprStatement(expr);
+                statementList.add(stmt);
+                continue;
             }
 
             if (lexer.token() == Token.LPAREN) {
+                char ch = lexer.current();
+                int bp = lexer.bp();
                 lexer.nextToken();
-                parseStatementList(statementList, statementList.size() + 1);
-                accept(Token.RPAREN);
-                continue;
+
+                if (lexer.token() == Token.SELECT) {
+                    lexer.reset(bp, ch, Token.LPAREN);
+                    statementList.add(this.parseSelect());
+                    continue;
+                } else {
+                    throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                }
             }
 
             if (lexer.token() == Token.SET) {
@@ -233,11 +261,74 @@ public class OracleStatementParser extends SQLStatementParser {
                 statementList.add(this.parseComment());
                 continue;
             }
+            if (lexer.token() == Token.FOR) {
+                statementList.add(this.parseFor());
+                continue;
+            }
+            if (lexer.token() == Token.IF) {
+                statementList.add(this.parseIf());
+                continue;
+            }
 
             throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
         }
     }
 
+    public SQLStatement parseIf() {
+        accept(Token.IF);
+
+        OracleIfStatement stmt = new OracleIfStatement();
+
+        stmt.setCondition(this.exprParser.expr());
+
+        accept(Token.THEN);
+
+        this.parseStatementList(stmt.getStatements());
+
+        while (lexer.token() == Token.ELSE) {
+            lexer.nextToken();
+
+            if (lexer.token() == Token.IF) {
+                lexer.nextToken();
+
+                OracleIfStatement.ElseIf elseIf = new OracleIfStatement.ElseIf();
+
+                elseIf.setCondition(this.exprParser.expr());
+
+                accept(Token.THEN);
+                this.parseStatementList(elseIf.getStatements());
+                
+                stmt.getElseIfList().add(elseIf);
+            } else {
+                OracleIfStatement.Else elseItem = new OracleIfStatement.Else();
+                this.parseStatementList(elseItem.getStatements());
+                stmt.setElseItem(elseItem);
+                break;
+            }
+        }
+        
+        accept(Token.END);
+        accept(Token.IF);
+
+        return stmt;
+    }
+
+    public OracleForStatement parseFor() {
+        accept(Token.FOR);
+
+        OracleForStatement stmt = new OracleForStatement();
+
+        stmt.setIndex(this.exprParser.name());
+        accept(Token.IN);
+        stmt.setRange(this.exprParser.expr());
+        accept(Token.LOOP);
+
+        this.parseStatementList(stmt.getStatements());
+        accept(Token.END);
+        accept(Token.LOOP);
+        return stmt;
+    }
+
     public SQLStatement parseGrant() {
         accept(Token.GRANT);
         OracleGrantStatement stmt = new OracleGrantStatement();
@@ -315,11 +406,210 @@ public class OracleStatementParser extends SQLStatementParser {
             } else {
                 throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
             }
+            return stmt;
+        } else if (lexer.token() == Token.PROCEDURE) {
+            lexer.nextToken();
+            OracleAlterProcedureStatement stmt = new OracleAlterProcedureStatement();
+            stmt.setName(this.exprParser.name());
+            if (identifierEquals("COMPILE")) {
+                lexer.nextToken();
+                stmt.setCompile(true);
+            }
+
+            if (identifierEquals("REUSE")) {
+                lexer.nextToken();
+                acceptIdentifier("SETTINGS");
+                stmt.setReuseSettings(true);
+            }
+
+            return stmt;
+        } else if (lexer.token() == Token.TABLE) {
+            return parseAlterTable();
+        } else if (lexer.token() == Token.INDEX) {
+            lexer.nextToken();
+            OracleAlterIndexStatement stmt = new OracleAlterIndexStatement();
+            stmt.setName(this.exprParser.name());
+
+            if (identifierEquals("rebuild")) {
+                lexer.nextToken();
+
+                OracleAlterIndexStatement.Rebuild rebuild = new OracleAlterIndexStatement.Rebuild();
+                stmt.setRebuild(rebuild);
+            } else if (identifierEquals("MONITORING")) {
+                lexer.nextToken();
+                acceptIdentifier("USAGE");
+                stmt.setMonitoringUsage(Boolean.TRUE);
+            }
+
             return stmt;
         }
+
         throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
     }
 
+    private OracleStatement parseAlterTable() {
+        lexer.nextToken();
+        OracleAlterTableStatement stmt = new OracleAlterTableStatement();
+        stmt.setName(this.exprParser.name());
+
+        for (;;) {
+            if (identifierEquals("ADD")) {
+                lexer.nextToken();
+
+                SQLColumnDefinition columnDef;
+                if (lexer.token() == Token.LPAREN) {
+                    lexer.nextToken();
+                    columnDef = this.exprParser.parseColumn();
+                    accept(Token.RPAREN);
+                } else {
+                    columnDef = this.exprParser.parseColumn();
+                }
+
+                OracleAlterTableAddColumn item = new OracleAlterTableAddColumn();
+                item.setColumn(columnDef);
+
+                stmt.getItems().add(item);
+                continue;
+            } else if (identifierEquals("MOVE")) {
+                throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+            } else if (identifierEquals("RENAME")) {
+                throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+            } else if (identifierEquals("MODIFY")) {
+                lexer.nextToken();
+
+                if (lexer.token() == Token.LPAREN) {
+                    lexer.nextToken();
+                    OracleAlterTableModify item = new OracleAlterTableModify();
+
+                    for (;;) {
+                        SQLColumnDefinition columnDef = this.exprParser.parseColumn();
+                        item.getColumns().add(columnDef);
+                        if (lexer.token() == Token.COMMA) {
+                            lexer.nextToken();
+                            continue;
+                        }
+                        break;
+                    }
+                    accept(Token.RPAREN);
+                    stmt.getItems().add(item);
+                } else {
+                    throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                }
+
+                continue;
+            } else if (identifierEquals("SPLIT")) {
+                parseAlterTableSplit(stmt);
+                continue;
+            } else if (lexer.token() == Token.TRUNCATE) {
+                lexer.nextToken();
+                if (identifierEquals("PARTITION")) {
+                    lexer.nextToken();
+                    OracleAlterTableTruncatePartition item = new OracleAlterTableTruncatePartition();
+                    item.setName(this.exprParser.name());
+                    stmt.getItems().add(item);
+                } else {
+                    throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                }
+                continue;
+            } else if (lexer.token() == Token.DROP) {
+                parseAlterTableDrop(stmt);
+                continue;
+            }
+
+            break;
+        }
+
+        return stmt;
+    }
+
+    private void parseAlterTableDrop(OracleAlterTableStatement stmt) {
+        lexer.nextToken();
+        if (identifierEquals("PARTITION")) {
+            lexer.nextToken();
+            OracleAlterTableDropPartition item = new OracleAlterTableDropPartition();
+            item.setName(this.exprParser.name());
+            stmt.getItems().add(item);
+        } else {
+            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+        }
+    }
+
+    private void parseAlterTableSplit(OracleAlterTableStatement stmt) {
+        lexer.nextToken();
+        if (identifierEquals("PARTITION")) {
+            lexer.nextToken();
+            OracleAlterTableSplitPartition item = new OracleAlterTableSplitPartition();
+            item.setName(this.exprParser.name());
+
+            if (lexer.token() == Token.AT) {
+                lexer.nextToken();
+                accept(Token.LPAREN);
+                this.exprParser.exprList(item.getAt());
+                accept(Token.RPAREN);
+            } else {
+                throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+            }
+
+            if (lexer.token() == Token.INTO) {
+                lexer.nextToken();
+                accept(Token.LPAREN);
+
+                for (;;) {
+                    NestedTablePartitionSpec spec = new NestedTablePartitionSpec();
+                    acceptIdentifier("PARTITION");
+                    spec.setPartition(this.exprParser.name());
+
+                    for (;;) {
+                        if (identifierEquals("TABLESPACE")) {
+                            lexer.nextToken();
+                            SQLName tablespace = this.exprParser.name();
+                            spec.getSegmentAttributeItems().add(new TableSpaceItem(tablespace));
+                            continue;
+                        } else if (identifierEquals("PCTREE")) {
+                            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                        } else if (identifierEquals("PCTUSED")) {
+                            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                        } else if (identifierEquals("INITRANS")) {
+                            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+
+                        } else if (identifierEquals("STORAGE")) {
+                            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+
+                        } else if (identifierEquals("LOGGING")) {
+                            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                        } else if (identifierEquals("NOLOGGING")) {
+                            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                        } else if (identifierEquals("FILESYSTEM_LIKE_LOGGING")) {
+                            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+
+                        }
+
+                        break;
+                    }
+
+                    item.getInto().add(spec);
+
+                    if (lexer.token() == Token.COMMA) {
+                        lexer.nextToken();
+                        continue;
+                    }
+                    break;
+                }
+                accept(Token.RPAREN);
+            }
+
+            if (lexer.token() == Token.UPDATE) {
+                lexer.nextToken();
+                acceptIdentifier("INDEXES");
+                UpdateIndexesClause updateIndexes = new UpdateIndexesClause();
+                item.setUpdateIndexes(updateIndexes);
+            }
+            stmt.getItems().add(item);
+        } else {
+            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+        }
+    }
+
     public OracleLockTableStatement parseLock() {
         accept(Token.LOCK);
         accept(Token.TABLE);
@@ -347,12 +637,30 @@ public class OracleStatementParser extends SQLStatementParser {
     }
 
     public OracleStatement parseBlock() {
+        OracleBlockStatement block = new OracleBlockStatement();
+
         if (lexer.token() == Token.DECLARE) {
-            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+            lexer.nextToken();
+
+            for (;;) {
+                SQLColumnDefinition parameter = this.exprParser.parseColumn();
+                block.getParameters().add(parameter);
+                
+                if (lexer.token() == Token.COLONEQ) {
+                    lexer.nextToken();
+                    parameter.setDefaultExpr(this.exprParser.expr());
+                }
+                parameter.setParent(block);
+                accept(Token.SEMI);
+                if (lexer.token() != Token.BEGIN) {
+                    continue;
+                }
+
+                break;
+            }
         }
 
         accept(Token.BEGIN);
-        OracleBlockStatement block = new OracleBlockStatement();
 
         parseStatementList(block.getStatementList());
 
@@ -597,7 +905,7 @@ public class OracleStatementParser extends SQLStatementParser {
         return null;
     }
 
-    private OracleReturningClause parseReturningClause() {
+    public OracleReturningClause parseReturningClause() {
         OracleReturningClause clause = null;
 
         if (lexer.token() == Token.RETURNING) {
@@ -626,4 +934,132 @@ public class OracleStatementParser extends SQLStatementParser {
         }
         return clause;
     }
+
+    public SQLStatement parseStatement() {
+        List<SQLStatement> list = new ArrayList<SQLStatement>();
+
+        this.parseStatementList(list, 1);
+
+        return list.get(0);
+    }
+
+    public OracleExplainStatement parseExplain() {
+        acceptIdentifier("EXPLAIN");
+        acceptIdentifier("PLAN");
+        OracleExplainStatement stmt = new OracleExplainStatement();
+
+        if (lexer.token() == Token.SET) {
+            lexer.nextToken();
+            acceptIdentifier("STATEMENT_ID");
+            accept(Token.EQ);
+            stmt.setStatementId((SQLCharExpr) this.exprParser.primary());
+        }
+
+        if (lexer.token() == Token.INTO) {
+            lexer.nextToken();
+            stmt.setInto(this.exprParser.name());
+        }
+
+        accept(Token.FOR);
+        stmt.setForStatement(parseStatement());
+
+        return stmt;
+    }
+
+    public OracleDeleteStatement parseDelete() throws ParserException {
+        accept(Token.DELETE);
+
+        OracleDeleteStatement deleteStatement = new OracleDeleteStatement();
+
+        this.createExprParser().parseHints(deleteStatement.getHints());
+
+        if (lexer.token() == (Token.FROM)) {
+            lexer.nextToken();
+        }
+
+        if (identifierEquals("ONLY")) {
+            lexer.nextToken();
+            accept(Token.LPAREN);
+
+            SQLName tableName = exprParser.name();
+            deleteStatement.setTableName(tableName);
+
+            accept(Token.RPAREN);
+        } else {
+            SQLName tableName = exprParser.name();
+            deleteStatement.setTableName(tableName);
+        }
+
+        deleteStatement.setAlias(as());
+
+        if (lexer.token() == (Token.WHERE)) {
+            lexer.nextToken();
+            deleteStatement.setWhere(this.exprParser.expr());
+        }
+
+        if (lexer.token() == Token.RETURNING) {
+            OracleReturningClause clause = this.parseReturningClause();
+            deleteStatement.setReturning(clause);
+        }
+        if (identifierEquals("RETURN") || identifierEquals("RETURNING")) {
+            throw new ParserException("TODO");
+        }
+
+        if (identifierEquals("LOG")) {
+            throw new ParserException("TODO");
+        }
+
+        return deleteStatement;
+    }
+
+    public OracleCreateIndexStatement parseCreateIndex(boolean acceptCreate) {
+        if (acceptCreate) {
+            accept(Token.CREATE);
+        }
+
+        OracleCreateIndexStatement stmt = new OracleCreateIndexStatement();
+        if (lexer.token() == Token.UNION) {
+            stmt.setType(OracleCreateIndexStatement.Type.UNIQUE);
+            lexer.nextToken();
+        } else if (identifierEquals("BITMAP")) {
+            stmt.setType(OracleCreateIndexStatement.Type.BITMAP);
+            lexer.nextToken();
+        }
+
+        accept(Token.INDEX);
+
+        stmt.setName(this.exprParser.name());
+
+        accept(Token.ON);
+
+        stmt.setTable(this.exprParser.name());
+
+        accept(Token.LPAREN);
+
+        for (;;) {
+            SQLSelectOrderByItem item = this.exprParser.parseSelectOrderByItem();
+            stmt.getItems().add(item);
+            if (lexer.token() == Token.COMMA) {
+                lexer.nextToken();
+                continue;
+            }
+            break;
+        }
+        accept(Token.RPAREN);
+
+        for (;;) {
+            if (identifierEquals("TABLESPACE")) {
+                lexer.nextToken();
+                stmt.setTablespace(this.exprParser.name());
+                continue;
+            } else if (identifierEquals("ONLINE")) {
+                lexer.nextToken();
+                stmt.setOnline(true);
+                continue;
+            } else {
+                break;
+            }
+        }
+        return stmt;
+    }
 }

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

@@ -37,20 +37,35 @@ 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.OracleRangeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleSysdateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableDropPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableModify;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableTruncatePartition;
 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.OracleCreateIndexStatement;
 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.OracleExplainStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement.Else;
+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.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;
@@ -810,12 +825,12 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora
     }
 
     @Override
-    public boolean visit(OracleMethodInvokeStatement x) {
+    public boolean visit(OracleExprStatement x) {
         return true;
     }
 
     @Override
-    public void endVisit(OracleMethodInvokeStatement x) {
+    public void endVisit(OracleExprStatement x) {
 
     }
 
@@ -866,7 +881,7 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora
 
     @Override
     public void endVisit(OracleArgumentExpr x) {
-        
+
     }
 
     @Override
@@ -876,16 +891,206 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora
 
     @Override
     public void endVisit(OracleSetTransactionStatement x) {
-        
+
     }
-    
+
     @Override
     public boolean visit(OracleGrantStatement x) {
         return true;
     }
-    
+
     @Override
     public void endVisit(OracleGrantStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleExplainStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleExplainStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterProcedureStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleAlterProcedureStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableDropPartition x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableDropPartition x) {
+
+    }
+    
+    @Override
+    public boolean visit(OracleAlterTableTruncatePartition x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterTableTruncatePartition x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableStatement x) {
+
+    }
+    
+    @Override
+    public boolean visit(OracleAlterTableSplitPartition.TableSpaceItem x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterTableSplitPartition.TableSpaceItem x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleAlterTableSplitPartition.UpdateIndexesClause x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterTableSplitPartition.UpdateIndexesClause x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableSplitPartition x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableSplitPartition x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleAlterTableModify x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterTableModify x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleAlterTableAddColumn x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterTableAddColumn x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleCreateIndexStatement x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleCreateIndexStatement x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleAlterIndexStatement x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterIndexStatement x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleForStatement x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleForStatement x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleAlterIndexStatement.Rebuild x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterIndexStatement.Rebuild x) {
+        
+    }
+
+    @Override
+    public boolean visit(Else x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(Else x) {
+        
+    }
+    
+    @Override
+    public boolean visit(ElseIf x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(ElseIf x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleIfStatement x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleIfStatement x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleRangeExpr x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleRangeExpr x) {
         
     }
 

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

@@ -43,18 +43,33 @@ 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.OracleRangeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleSysdateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableDropPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableModify;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableTruncatePartition;
 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.OracleCreateIndexStatement;
 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.OracleExplainStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement.Else;
+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.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;
@@ -301,92 +316,168 @@ public interface OracleASTVisitor extends SQLASTVisitor {
     boolean visit(ModelClause x);
 
     void endVisit(ModelClause x);
-    
+
     boolean visit(OracleMergeStatement x);
-    
+
     void endVisit(OracleMergeStatement x);
-    
+
     boolean visit(OracleMergeStatement.MergeUpdateClause x);
-    
+
     void endVisit(OracleMergeStatement.MergeUpdateClause x);
-    
+
     boolean visit(OracleMergeStatement.MergeInsertClause x);
-    
+
     void endVisit(OracleMergeStatement.MergeInsertClause x);
-    
+
     boolean visit(OracleErrorLoggingClause x);
-    
+
     void endVisit(OracleErrorLoggingClause x);
-    
+
     boolean visit(OracleReturningClause x);
-    
+
     void endVisit(OracleReturningClause x);
-    
+
     boolean visit(OracleInsertStatement x);
-    
+
     void endVisit(OracleInsertStatement x);
-    
+
     boolean visit(InsertIntoClause x);
-    
+
     void endVisit(InsertIntoClause x);
-    
+
     boolean visit(OracleMultiInsertStatement x);
-    
+
     void endVisit(OracleMultiInsertStatement x);
-    
+
     boolean visit(ConditionalInsertClause x);
-    
+
     void endVisit(ConditionalInsertClause x);
-    
+
     boolean visit(ConditionalInsertClauseItem x);
-    
+
     void endVisit(ConditionalInsertClauseItem x);
-    
+
     boolean visit(OracleSelectQueryBlock x);
-    
+
     void endVisit(OracleSelectQueryBlock x);
-    
+
     boolean visit(OracleBlockStatement x);
-    
+
     void endVisit(OracleBlockStatement x);
-    
+
     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(OracleExprStatement x);
+
+    void endVisit(OracleExprStatement x);
+
     boolean visit(OracleDatetimeExpr x);
-    
+
     void endVisit(OracleDatetimeExpr x);
-    
+
     boolean visit(OracleSysdateExpr x);
-    
+
     void endVisit(OracleSysdateExpr x);
-    
+
     boolean visit(OracleExceptionStatement x);
-    
+
     void endVisit(OracleExceptionStatement x);
-    
+
     boolean visit(OracleExceptionStatement.Item x);
-    
+
     void endVisit(OracleExceptionStatement.Item x);
-    
+
     boolean visit(OracleArgumentExpr x);
-    
+
     void endVisit(OracleArgumentExpr x);
-    
+
     boolean visit(OracleSetTransactionStatement x);
-    
+
     void endVisit(OracleSetTransactionStatement x);
-    
+
     boolean visit(OracleGrantStatement x);
-    
+
     void endVisit(OracleGrantStatement x);
+
+    boolean visit(OracleExplainStatement x);
+
+    void endVisit(OracleExplainStatement x);
+
+    boolean visit(OracleAlterProcedureStatement x);
+
+    void endVisit(OracleAlterProcedureStatement x);
+
+    boolean visit(OracleAlterTableDropPartition x);
+
+    void endVisit(OracleAlterTableDropPartition x);
+
+    boolean visit(OracleAlterTableTruncatePartition x);
+
+    void endVisit(OracleAlterTableTruncatePartition x);
+
+    boolean visit(OracleAlterTableStatement x);
+
+    void endVisit(OracleAlterTableStatement x);
+    
+    boolean visit(OracleAlterTableSplitPartition.TableSpaceItem x);
+    
+    void endVisit(OracleAlterTableSplitPartition.TableSpaceItem x);
+    
+    boolean visit(OracleAlterTableSplitPartition.UpdateIndexesClause x);
+    
+    void endVisit(OracleAlterTableSplitPartition.UpdateIndexesClause x);
+    
+    boolean visit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x);
+    
+    void endVisit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x);
+    
+    boolean visit(OracleAlterTableSplitPartition x);
+    
+    void endVisit(OracleAlterTableSplitPartition x);
+    
+    boolean visit(OracleAlterTableModify x);
+    
+    void endVisit(OracleAlterTableModify x);
+    
+    boolean visit(OracleAlterTableAddColumn x);
+    
+    void endVisit(OracleAlterTableAddColumn x);
+    
+    boolean visit(OracleCreateIndexStatement x);
+    
+    void endVisit(OracleCreateIndexStatement x);
+    
+    boolean visit(OracleForStatement x);
+    
+    void endVisit(OracleForStatement x);
+    
+    boolean visit(Else x);
+    
+    void endVisit(Else x);
+    
+    boolean visit(ElseIf x);
+    
+    void endVisit(ElseIf x);
+    
+    boolean visit(OracleIfStatement x);
+    
+    void endVisit(OracleIfStatement x);
+    
+    boolean visit(OracleRangeExpr x);
+    
+    void endVisit(OracleRangeExpr x);
+    
+    boolean visit(OracleAlterIndexStatement x);
+    
+    void endVisit(OracleAlterIndexStatement x);
+    
+    boolean visit(OracleAlterIndexStatement.Rebuild x);
+    
+    void endVisit(OracleAlterIndexStatement.Rebuild x);
 }

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

@@ -28,6 +28,7 @@ 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;
+import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 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;
@@ -70,20 +71,40 @@ 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.OracleRangeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleSysdateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement.Rebuild;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableDropPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableItem;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableModify;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.NestedTablePartitionSpec;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.TableSpaceItem;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.UpdateIndexesClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableTruncatePartition;
 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.OracleCreateIndexStatement;
 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.OracleExplainStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement.Else;
+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.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;
@@ -124,7 +145,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
                 return;
             }
 
-            if (x.getParent() instanceof SQLStatement) {
+            if (x.getParent() != null) {
                 print(";");
             } else {
                 println(";");
@@ -231,6 +252,11 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
             x.getWhere().accept(this);
         }
 
+        if (x.getReturning() != null) {
+            println();
+            x.getReturning().accept(this);
+        }
+
         return false;
     }
 
@@ -349,7 +375,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
             printAndAccept(x.getOf(), ", ");
             print(")");
         }
-        
+
         if (x.isNotWait()) {
             print(" NOWAIT");
         } else if (x.isSkipLocked()) {
@@ -407,12 +433,12 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
             printAndAccept(x.getUsing(), ", ");
             print(")");
         }
-        
+
         if (x.getFlashback() != null) {
             println();
             x.getFlashback().accept(this);
         }
-        
+
         return false;
     }
 
@@ -496,7 +522,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
         }
 
         printSelectList(select.getSelectList());
-        
+
         if (select.getInto() != null) {
             println();
             print("INTO ");
@@ -556,7 +582,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
         println();
         decrementIndent();
         print(")");
-        
+
         if (x.getPivot() != null) {
             incrementIndent();
 
@@ -565,7 +591,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
             decrementIndent();
         }
-        
+
         if (x.getFlashback() != null) {
             println();
             x.getFlashback().accept(this);
@@ -598,7 +624,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
                 x.getPartition().accept(this);
             }
         }
-        
+
         if (x.getHints().size() > 0) {
             this.printHints(x.getHints());
         }
@@ -1624,9 +1650,9 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
             if (i != 0) {
                 println();
             }
-            
+
             ConditionalInsertClauseItem item = x.getItems().get(i);
-            
+
             item.accept(this);
         }
 
@@ -1661,16 +1687,28 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public void endVisit(ConditionalInsertClauseItem x) {
-        
+
     }
 
     @Override
     public void endVisit(OracleSelectQueryBlock x) {
-        
+
     }
 
     @Override
     public boolean visit(OracleBlockStatement x) {
+        if (x.getParameters().size() != 0) {
+            print("DECLARE");
+            incrementIndent();
+            println();
+
+            for (SQLColumnDefinition param : x.getParameters()) {
+                param.accept(this);
+                println();
+            }
+
+            decrementIndent();
+        }
         print("BEGIN");
         incrementIndent();
         println();
@@ -1690,7 +1728,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public void endVisit(OracleBlockStatement x) {
-        
+
     }
 
     @Override
@@ -1702,7 +1740,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
         print(" MODE ");
         if (x.isNoWait()) {
             print("NOWAIT");
-        } else if (x.getWait() != null){
+        } else if (x.getWait() != null) {
             print("WAIT ");
             x.getWait().accept(this);
         }
@@ -1711,7 +1749,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public void endVisit(OracleLockTableStatement x) {
-        
+
     }
 
     @Override
@@ -1723,41 +1761,41 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public void endVisit(OracleAlterSessionStatement x) {
-        
+
     }
 
     @Override
-    public boolean visit(OracleMethodInvokeStatement x) {
+    public boolean visit(OracleExprStatement x) {
         x.getExpr().accept(this);
         return false;
     }
 
     @Override
-    public void endVisit(OracleMethodInvokeStatement x) {
-        
+    public void endVisit(OracleExprStatement 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) {
-        
+
     }
 
     @Override
@@ -1772,12 +1810,12 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public void endVisit(OracleSysdateExpr x) {
-        
+
     }
 
     @Override
     public void endVisit(com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement.Item x) {
-        
+
     }
 
     @Override
@@ -1805,7 +1843,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public void endVisit(OracleExceptionStatement x) {
-        
+
     }
 
     @Override
@@ -1818,7 +1856,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public void endVisit(OracleArgumentExpr x) {
-        
+
     }
 
     @Override
@@ -1830,7 +1868,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public void endVisit(OracleSetTransactionStatement x) {
-        
+
     }
 
     @Override
@@ -1842,7 +1880,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
             }
             print(x.getPrivileges().get(i));
         }
-        
+
         if (x.getOn() != null) {
             print(" ON ");
             x.getOn().accept(this);
@@ -1852,6 +1890,421 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
 
     @Override
     public void endVisit(OracleGrantStatement x) {
-        
+
+    }
+
+    @Override
+    public boolean visit(OracleExplainStatement x) {
+        print("XPLAIN PLAN");
+        incrementIndent();
+        println();
+        if (x.getStatementId() != null) {
+            print("SET STATEMENT_ID = ");
+            x.getStatementId().accept(this);
+            println();
+        }
+
+        if (x.getInto() != null) {
+            print("INTO ");
+            x.getInto().accept(this);
+            println();
+        }
+
+        print("FRO");
+        println();
+        x.getForStatement().accept(this);
+
+        decrementIndent();
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleExplainStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterProcedureStatement x) {
+        print("ALTER PROCEDURE ");
+        x.getName().accept(this);
+        if (x.isCompile()) {
+            print(" COMPILE");
+        }
+        if (x.isReuseSettings()) {
+            print(" REUSE SETTINGS");
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterProcedureStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableDropPartition x) {
+        print("DROP PARTITION ");
+        x.getName().accept(this);
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableDropPartition x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableStatement x) {
+        print("ALTER TABLE ");
+        x.getName().accept(this);
+        incrementIndent();
+        for (OracleAlterTableItem item : x.getItems()) {
+            println();
+            item.accept(this);
+        }
+        decrementIndent();
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableTruncatePartition x) {
+        print("TRUNCATE PARTITION ");
+        x.getName().accept(this);
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableTruncatePartition x) {
+
+    }
+
+    @Override
+    public boolean visit(TableSpaceItem x) {
+        print("TABLESPACE ");
+        x.getTablespace().accept(this);
+        return false;
+    }
+
+    @Override
+    public void endVisit(TableSpaceItem x) {
+
+    }
+
+    @Override
+    public boolean visit(UpdateIndexesClause x) {
+        print("UPDATE INDEXES");
+        if (x.getItems().size() > 0) {
+            print("(");
+            printAndAccept(x.getItems(), ", ");
+            print(")");
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(UpdateIndexesClause x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableSplitPartition x) {
+        print("SPLIT PARTITION ");
+        x.getName().accept(this);
+
+        if (x.getAt().size() > 0) {
+            incrementIndent();
+            println();
+            print("AT (");
+            printAndAccept(x.getAt(), ", ");
+            print(")");
+            decrementIndent();
+        }
+
+        if (x.getInto().size() > 0) {
+            println();
+            incrementIndent();
+            print("INTO (");
+            printAndAccept(x.getInto(), ", ");
+            print(")");
+            decrementIndent();
+        }
+
+        if (x.getUpdateIndexes() != null) {
+            println();
+            incrementIndent();
+            x.getUpdateIndexes().accept(this);
+            decrementIndent();
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableSplitPartition x) {
+
+    }
+
+    @Override
+    public boolean visit(NestedTablePartitionSpec x) {
+        print("PARTITION ");
+        x.getPartition().accept(this);
+        for (SQLObject item : x.getSegmentAttributeItems()) {
+            print(" ");
+            item.accept(this);
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(NestedTablePartitionSpec x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableModify x) {
+        print("MODIFY (");
+        incrementIndent();
+        for (int i = 0, size = x.getColumns().size(); i < size; ++i) {
+            println();
+            SQLColumnDefinition column = x.getColumns().get(i);
+            column.accept(this);
+            if (i != size - 1) {
+                print(", ");
+            }
+        }
+        decrementIndent();
+        println();
+        print(")");
+
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableModify x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableAddColumn x) {
+        print("ADD (");
+        x.getColumn().accept(this);
+        print(")");
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableAddColumn x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleCreateIndexStatement x) {
+        print("CREATE INDEX ");
+        if (x.getType() != null) {
+            print(x.getType().name());
+            print(" ");
+        }
+
+        x.getName().accept(this);
+        print(" ON ");
+        x.getTable().accept(this);
+        print("(");
+        printAndAccept(x.getItems(), ", ");
+        print(")");
+        if (x.getTablespace() != null) {
+            print(" TABLESPACE ");
+            x.getTablespace().accept(this);
+        }
+
+        if (x.isOnline()) {
+            print(" ONLINE");
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleCreateIndexStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterIndexStatement x) {
+        print("ALTER INDEX ");
+        x.getName().accept(this);
+
+        if (x.getMonitoringUsage() != null) {
+            print(" MONITORING USAGE");
+        }
+
+        if (x.getRebuild() != null) {
+            print(" ");
+            x.getRebuild().accept(this);
+        }
+
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterIndexStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(Rebuild x) {
+        print("REBUILD");
+
+        if (x.getOption() != null) {
+            print(" ");
+            x.getOption().accept(this);
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(Rebuild x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleForStatement x) {
+        print("FOR ");
+        x.getIndex().accept(this);
+        print(" IN ");
+        x.getRange().accept(this);
+        println();
+        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(OracleForStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(Else x) {
+        print("ELSE");
+        incrementIndent();
+        println();
+
+        for (int i = 0, size = x.getStatements().size(); i < size; ++i) {
+            if (i != 0) {
+                println();
+            }
+            SQLStatement item = x.getStatements().get(i);
+            item.setParent(x);
+            item.accept(this);
+        }
+
+        decrementIndent();
+        return false;
+    }
+
+    @Override
+    public boolean visit(ElseIf x) {
+        print("ELSE IF ");
+        x.getCondition().accept(this);
+        print(" THEN");
+        incrementIndent();
+        println();
+
+        for (int i = 0, size = x.getStatements().size(); i < size; ++i) {
+            if (i != 0) {
+                println();
+            }
+            SQLStatement item = x.getStatements().get(i);
+            item.setParent(x);
+            item.accept(this);
+        }
+
+        decrementIndent();
+        return false;
+    }
+
+    @Override
+    public void endVisit(ElseIf x) {
+
+    }
+
+    @Override
+    public void endVisit(Else x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleIfStatement x) {
+        print("IF ");
+        x.getCondition().accept(this);
+        print(" THEN");
+        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();
+
+        for (ElseIf elseIf : x.getElseIfList()) {
+            println();
+            elseIf.accept(this);
+        }
+
+        if (x.getElseItem() != null) {
+            println();
+            x.getElseItem().accept(this);
+        }
+        println();
+        print("END IF");
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleIfStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleRangeExpr x) {
+        x.getLowBound().accept(this);
+        print("..");
+        x.getUpBound().accept(this);
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleRangeExpr x) {
+
+    }
+
+    protected void visitColumnDefault(SQLColumnDefinition x) {
+        if (x.getParent() instanceof OracleBlockStatement) {
+            print(" := ");
+        } else {
+            print(" DEFAULT ");
+        }
+        x.getDefaultExpr().accept(this);
     }
 }

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

@@ -54,20 +54,35 @@ 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.OracleRangeExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleSysdateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleTimestampExpr;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableDropPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableModify;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableTruncatePartition;
 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.OracleCreateIndexStatement;
 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.OracleExplainStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExprStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleIfStatement.Else;
+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.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;
@@ -228,11 +243,11 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
         SQLTableSource tableSource = x.getTableSource();
         SQLExpr tableExpr = null;
-        
+
         if (tableSource instanceof SQLExprTableSource) {
-            tableExpr = ((SQLExprTableSource) tableSource).getExpr(); 
+            tableExpr = ((SQLExprTableSource) tableSource).getExpr();
         }
-        
+
         if (tableExpr instanceof SQLIdentifierExpr) {
             String ident = tableExpr.toString();
             currentTableLocal.set(ident);
@@ -1129,15 +1144,15 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
     public void endVisit(OracleAlterSessionStatement x) {
 
     }
-    
+
     @Override
-    public boolean visit(OracleMethodInvokeStatement x) {
+    public boolean visit(OracleExprStatement x) {
         return false;
     }
-    
+
     @Override
-    public void endVisit(OracleMethodInvokeStatement x) {
-        
+    public void endVisit(OracleExprStatement x) {
+
     }
 
     @Override
@@ -1160,7 +1175,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleDatetimeExpr x) {
-        
+
     }
 
     @Override
@@ -1170,12 +1185,12 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleSysdateExpr x) {
-        
+
     }
 
     @Override
     public void endVisit(com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement.Item x) {
-        
+
     }
 
     @Override
@@ -1190,7 +1205,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleExceptionStatement x) {
-        
+
     }
 
     @Override
@@ -1200,7 +1215,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleArgumentExpr x) {
-        
+
     }
 
     @Override
@@ -1210,7 +1225,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleSetTransactionStatement x) {
-        
+
     }
 
     @Override
@@ -1220,6 +1235,203 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
 
     @Override
     public void endVisit(OracleGrantStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleExplainStatement x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleExplainStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterProcedureStatement x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterProcedureStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableDropPartition x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableDropPartition x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableTruncatePartition x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableTruncatePartition x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableStatement x) {
+        String tableName = x.getName().toString();
+        TableStat stat = new TableStat();
+        stat.incrementAlterCount();
+        this.tableStats.put(new TableStat.Name(tableName), stat);
+
+        accept(x.getItems());
+
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableSplitPartition.TableSpaceItem x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableSplitPartition.TableSpaceItem x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableSplitPartition.UpdateIndexesClause x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableSplitPartition.UpdateIndexesClause x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableSplitPartition x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableSplitPartition x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableModify x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableModify x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableAddColumn x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableAddColumn x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleCreateIndexStatement x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleCreateIndexStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterIndexStatement x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterIndexStatement x) {
+
+    }
+    
+    @Override
+    public boolean visit(OracleForStatement x) {
+        return false;
+    }
+    
+    @Override
+    public void endVisit(OracleForStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterIndexStatement.Rebuild x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterIndexStatement.Rebuild x) {
+
+    }
+
+    @Override
+    public boolean visit(Else x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(Else x) {
+        
+    }
+    
+    @Override
+    public boolean visit(ElseIf x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(ElseIf x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleIfStatement x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleIfStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleRangeExpr x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleRangeExpr x) {
         
     }
 }

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

@@ -66,7 +66,7 @@ public class SQLCreateTableParser extends SQLDDLParser {
             lexer.nextToken();
 
             while (lexer.token() == Token.IDENTIFIER) {
-                SQLColumnDefinition column = parseColumn();
+                SQLColumnDefinition column = this.exprParser.parseColumn();
                 createTable.getTableElementList().add(column);
 
                 // parseConstaint(column.getConstaints());

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

@@ -16,8 +16,6 @@
 package com.alibaba.druid.sql.parser;
 
 import com.alibaba.druid.sql.ast.SQLName;
-import com.alibaba.druid.sql.ast.statement.NotNullConstraint;
-import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 import com.alibaba.druid.sql.ast.statement.SQLTableConstaint;
 
 public class SQLDDLParser extends SQLStatementParser {
@@ -30,31 +28,6 @@ public class SQLDDLParser extends SQLStatementParser {
         super(lexer);
     }
 
-    protected SQLColumnDefinition parseColumn() {
-        SQLColumnDefinition column = new SQLColumnDefinition();
-        column.setName(this.exprParser.name());
-        column.setDataType(this.exprParser.parseDataType());
-
-        return parseColumnRest(column);
-    }
-
-    protected SQLColumnDefinition parseColumnRest(SQLColumnDefinition column) {
-        if (lexer.token() == Token.DEFAULT) {
-            lexer.nextToken();
-            column.setDefaultExpr(this.exprParser.expr());
-            return parseColumnRest(column);
-        }
-
-        if (lexer.token() == Token.NOT) {
-            lexer.nextToken();
-            accept(Token.NULL);
-            column.getConstaints().add(new NotNullConstraint());
-            return parseColumnRest(column);
-        }
-
-        return column;
-    }
-
     protected SQLTableConstaint parseConstraint() {
         SQLName name = null;
         if (lexer.token() == Token.CONSTRAINT) {

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

@@ -53,7 +53,9 @@ import com.alibaba.druid.sql.ast.expr.SQLSomeExpr;
 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.ast.statement.NotNullConstraint;
 import com.alibaba.druid.sql.ast.statement.SQLCharactorDataType;
+import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 import com.alibaba.druid.sql.ast.statement.SQLSelect;
 import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
 
@@ -375,6 +377,13 @@ public class SQLExprParser extends SQLParser {
             case INTERVAL:
                 sqlExpr = parseInterval();
                 break;
+            case COLON:
+                lexer.nextToken();
+                if (lexer.token == Token.LITERAL_ALIAS) {
+                    sqlExpr = new SQLVariantRefExpr(":\"" + lexer.stringVal() + "\"");
+                    lexer.nextToken();
+                }
+                break;
             case ANY:
                 lexer.nextToken();
                 if (lexer.token() == Token.LPAREN) {
@@ -440,6 +449,7 @@ public class SQLExprParser extends SQLParser {
 
         if (lexer.token() == Token.DOT) {
             lexer.nextToken();
+            
             expr = dotRest(expr);
             return primaryRest(expr);
         } else if (lexer.token() == Token.COLONEQ) {
@@ -448,44 +458,49 @@ public class SQLExprParser extends SQLParser {
             expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Assignment, rightExp);
         } else {
             if (lexer.token() == Token.LPAREN) {
-                if (expr instanceof SQLName || expr instanceof SQLDefaultExpr) {
-                    String method_name;
-                    
-                    SQLMethodInvokeExpr methodInvokeExpr;
-                    if (expr instanceof SQLPropertyExpr) {
-                        method_name = ((SQLPropertyExpr) expr).getName();
-                        methodInvokeExpr = new SQLMethodInvokeExpr(method_name);
-                        methodInvokeExpr.setOwner(((SQLPropertyExpr) expr).getOwner());
-                    } else {
-                        method_name = expr.toString();
-                        methodInvokeExpr = new SQLMethodInvokeExpr(method_name);
-                    }
-                    
-                    lexer.nextToken();
-
-                    if (isAggreateFunction(method_name)) {
-                        SQLAggregateExpr aggregateExpr = parseAggregateExpr(method_name);
-
-                        return aggregateExpr;
-                    }
-
-                    
-                    if (lexer.token() != Token.RPAREN) {
-                        exprList(methodInvokeExpr.getParameters());
-                    }
-
-                    accept(Token.RPAREN);
-
-                    return primaryRest(methodInvokeExpr);
-                }
-
-                throw new ParserException("not support token:" + lexer.token());
+                return methodRest(expr, true);
             }
         }
 
         return expr;
     }
 
+    protected SQLExpr methodRest(SQLExpr expr, boolean acceptLPAREN) {
+        if (acceptLPAREN) {
+            accept(Token.LPAREN);
+        }
+
+        if (expr instanceof SQLName || expr instanceof SQLDefaultExpr) {
+            String method_name;
+
+            SQLMethodInvokeExpr methodInvokeExpr;
+            if (expr instanceof SQLPropertyExpr) {
+                method_name = ((SQLPropertyExpr) expr).getName();
+                methodInvokeExpr = new SQLMethodInvokeExpr(method_name);
+                methodInvokeExpr.setOwner(((SQLPropertyExpr) expr).getOwner());
+            } else {
+                method_name = expr.toString();
+                methodInvokeExpr = new SQLMethodInvokeExpr(method_name);
+            }
+
+            if (isAggreateFunction(method_name)) {
+                SQLAggregateExpr aggregateExpr = parseAggregateExpr(method_name);
+
+                return aggregateExpr;
+            }
+
+            if (lexer.token() != Token.RPAREN) {
+                exprList(methodInvokeExpr.getParameters());
+            }
+
+            accept(Token.RPAREN);
+
+            return primaryRest(methodInvokeExpr);
+        }
+
+        throw new ParserException("not support token:" + lexer.token());
+    }
+
     protected SQLExpr dotRest(SQLExpr expr) {
         if (lexer.token() == Token.STAR) {
             lexer.nextToken();
@@ -578,9 +593,12 @@ public class SQLExprParser extends SQLParser {
         } else if (lexer.token() == Token.IDENTIFIER) {
             identName = lexer.stringVal();
 
+            lexer.nextToken();
+        } else if (lexer.token() == Token.REFERENCE || lexer.token() == Token.DATE || lexer.token() == Token.TIMESTAMP) {
+            identName = lexer.stringVal();
             lexer.nextToken();
         } else {
-            throw new ParserException("error");
+            throw new ParserException("error " + lexer.token());
         }
 
         SQLName name = new SQLIdentifierExpr(identName);
@@ -1009,19 +1027,20 @@ public class SQLExprParser extends SQLParser {
 
             return expr;
         } else {
-            throw new ParserException("TODO");
+            throw new ParserException("TODO " + lexer.token());
         }
         return expr;
     }
 
     public SQLDataType parseDataType() throws ParserException {
-        if (lexer.token() != Token.DATE && lexer.token() != Token.TIMESTAMP && lexer.token() != Token.IDENTIFIER) {
-            throw new ParserException("unexpect token : " + lexer.token() + " " + lexer.stringVal());
+        
+        if (lexer.token() == Token.DEFAULT || lexer.token() == Token.NOT || lexer.token() == Token.NULL) {
+            return null;
         }
+        
+        SQLName typeExpr = name();
+        String typeName = typeExpr.toString();
 
-        String typeName = lexer.stringVal();
-
-        lexer.nextToken();
         SQLDataType dataType = new SQLDataTypeImpl(typeName);
         if (lexer.token() == Token.LPAREN) {
             lexer.nextToken();
@@ -1087,4 +1106,29 @@ public class SQLExprParser extends SQLParser {
             throw new SQLParseException("syntax error, expect " + token + ", actual " + lexer.token());
         }
     }
+    
+    public SQLColumnDefinition parseColumn() {
+        SQLColumnDefinition column = new SQLColumnDefinition();
+        column.setName(name());
+        column.setDataType(parseDataType());
+
+        return parseColumnRest(column);
+    }
+    
+    public SQLColumnDefinition parseColumnRest(SQLColumnDefinition column) {
+        if (lexer.token() == Token.DEFAULT) {
+            lexer.nextToken();
+            column.setDefaultExpr(bitOr());
+            return parseColumnRest(column);
+        }
+
+        if (lexer.token() == Token.NOT) {
+            lexer.nextToken();
+            accept(Token.NULL);
+            column.getConstaints().add(new NotNullConstraint());
+            return parseColumnRest(column);
+        }
+
+        return column;
+    }
 }

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

@@ -287,10 +287,16 @@ public class SQLStatementParser extends SQLParser {
         if (token == Token.TABLE) {
             SQLCreateTableParser createTableParser = getSQLCreateTableParser();
             return createTableParser.parseCrateTable(false);
+        } else if (token == Token.INDEX) {
+            return parseCreateIndex(false);
         }
 
         throw new ParserException("TODO " + lexer.token());
     }
+    
+    public SQLStatement parseCreateIndex(boolean acceptCreate) {
+        throw new ParserException("TODO " + lexer.token());
+    }
 
     public SQLCreateTableParser getSQLCreateTableParser() {
         return new SQLCreateTableParser(lexer);

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

@@ -23,6 +23,7 @@ package com.alibaba.druid.sql.parser;
  */
 public enum Token {
     FOR("FOR"), 
+    IF("IF"), 
     INDEX("INDEX"), 
     PRIMARY("PRIMARY"), 
     KEY("KEY"), 
@@ -159,6 +160,7 @@ public enum Token {
     WAIT("WAIT"),
     ADVISE("ADVISE"),
     SESSION("SESSION"),
+    PROCEDURE("PROCEDURE"),
     AT("AT"),
     LOCAL("LOCAL"),
     TIME("TIME"),
@@ -167,6 +169,7 @@ public enum Token {
     DECLARE("DECLARE"),
     EXCEPTION("EXCEPTION"),
     GRANT("GRANT"),
+    LOOP("LOOP"),
     
     // transact-sql
     TOP("TOP"),

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

@@ -396,7 +396,7 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter {
         if (parent instanceof SQLSelect) {
             parent = parent.getParent();
         }
-        
+
         if (parent instanceof SQLStatement) {
             incrementIndent();
 
@@ -553,12 +553,14 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter {
 
     public boolean visit(SQLColumnDefinition x) {
         x.getName().accept(this);
-        print(' ');
-        x.getDataType().accept(this);
+        
+        if (x.getDataType() != null) {
+            print(' ');
+            x.getDataType().accept(this);
+        }
 
         if (x.getDefaultExpr() != null) {
-            print(" DEFAULT ");
-            x.getDefaultExpr().accept(this);
+            visitColumnDefault(x);
         }
 
         for (SQLColumnConstraint item : x.getConstaints()) {
@@ -569,6 +571,11 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter {
         return false;
     }
 
+    protected void visitColumnDefault(SQLColumnDefinition x) {
+        print(" DEFAULT ");
+        x.getDefaultExpr().accept(this);
+    }
+
     public boolean visit(SQLDeleteStatement x) {
         print("DELETE FROM ");
 
@@ -888,16 +895,16 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter {
         printAndAccept(x.getTableNames(), ", ");
         return false;
     }
-    
+
     @Override
     public boolean visit(SQLDefaultExpr x) {
         print("DEFAULT");
         return false;
     }
-    
+
     @Override
     public void endVisit(SQLCommentStatement x) {
-        
+
     }
 
     @Override
@@ -908,10 +915,10 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter {
             print(" ");
         }
         x.getOn().accept(this);
-        
+
         print(" IS ");
         x.getComment().accept(this);
-        
+
         return false;
     }
 }

src/main/java/com/alibaba/druid/stat/TableStat.java

@@ -24,6 +24,15 @@ public class TableStat {
     int dropCount   = 0;
     int mergeCount  = 0;
     int createCount = 0;
+    int alterCount  = 0;
+
+    public int getAlterCount() {
+        return alterCount;
+    }
+
+    public void incrementAlterCount() {
+        this.alterCount++;
+    }
 
     public int getCreateCount() {
         return createCount;
@@ -124,6 +133,9 @@ public class TableStat {
         if (createCount > 0) {
             buf.append("Create");
         }
+        if (alterCount > 0) {
+            buf.append("Alter");
+        }
 
         return buf.toString();
     }