bug fixed for oracle sql parser

2023-03-04 19:17:16 +00:00 · 2012-03-06 22:52:24 +08:00
parent 1806ab3110 cad7e4320a
commit 74d4a2a82f
106 changed files with 2496 additions and 621 deletions
@@ -15,6 +15,6 @@
 */
 package com.alibaba.druid.sql.ast.statement;

-public interface SQLPrimaryKey extends SQLUniqueConstraint {
+public interface SQLPrimaryKey extends SQLUniqueConstraint, SQLTableElement {

 }
@@ -64,11 +64,7 @@ public class MySqlSchemaStatVisitor extends SchemaStatVisitor implements MySqlAS

        for (SQLName tableName : x.getTableNames()) {
            String ident = tableName.toString();
-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-            }
+            TableStat stat = getTableStat(ident);
            stat.incrementDeleteCount();
        }

@@ -100,11 +96,7 @@ public class MySqlSchemaStatVisitor extends SchemaStatVisitor implements MySqlAS
            String ident = ((SQLIdentifierExpr) x.getTableName()).getName();
            setCurrentTable(x, ident);

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-            }
+            TableStat stat = getTableStat(ident);
            stat.incrementInsertCount();

            Map<String, String> aliasMap = getAliasMap();
@@ -77,4 +77,27 @@ public abstract class FlashbackQueryClause extends OracleSQLObjectImpl {
            visitor.endVisit(this);
        }
    }
+    
+    public static class AsOfSnapshotClause extends FlashbackQueryClause {
+
+        private static final long serialVersionUID = 1L;
+
+        private SQLExpr           expr;
+
+        public SQLExpr getExpr() {
+            return expr;
+        }
+
+        public void setExpr(SQLExpr expr) {
+            this.expr = expr;
+        }
+
+        @Override
+        public void accept0(OracleASTVisitor visitor) {
+            if (visitor.visit(this)) {
+                acceptChild(visitor, expr);
+            }
+            visitor.endVisit(this);
+        }
+    }
 }
@@ -0,0 +1,51 @@
+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 OracleSizeExpr extends OracleSQLObjectImpl implements OracleExpr {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLExpr           value;
+    private Unit              unit;
+
+    public OracleSizeExpr(){
+
+    }
+
+    public OracleSizeExpr(SQLExpr value, Unit unit){
+        super();
+        this.value = value;
+        this.unit = unit;
+    }
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, value);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLExpr getValue() {
+        return value;
+    }
+
+    public void setValue(SQLExpr value) {
+        this.value = value;
+    }
+
+    public Unit getUnit() {
+        return unit;
+    }
+
+    public void setUnit(Unit unit) {
+        this.unit = unit;
+    }
+
+    public static enum Unit {
+        K, M, G, T, P, E
+    }
+}
@@ -1,5 +1,6 @@
 package com.alibaba.druid.sql.dialect.oracle.ast.stmt;

+import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLName;
 import com.alibaba.druid.sql.ast.SQLObject;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
@@ -19,15 +20,26 @@ public class OracleAlterIndexStatement extends OracleStatementImpl {

    private Rebuild           rebuild;

+    private SQLExpr           parallel;
+
    @Override
    public void accept0(OracleASTVisitor visitor) {
        if (visitor.visit(this)) {
            acceptChild(visitor, name);
            acceptChild(visitor, rebuild);
+            acceptChild(visitor, parallel);
        }
        visitor.endVisit(this);
    }

+    public SQLExpr getParallel() {
+        return parallel;
+    }
+
+    public void setParallel(SQLExpr parallel) {
+        this.parallel = parallel;
+    }
+
    public Boolean getMonitoringUsage() {
        return monitoringUsage;
    }
@@ -0,0 +1,48 @@
+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 OracleAlterSynonymStatement extends OracleStatementImpl {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLName           name;
+
+    private Boolean           enable;
+
+    private boolean           compile;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+        }
+        visitor.endVisit(this);
+    }
+
+    public Boolean getEnable() {
+        return enable;
+    }
+
+    public void setEnable(Boolean enable) {
+        this.enable = enable;
+    }
+
+    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;
+    }
+
+}
@@ -1,28 +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 OracleAlterTableAddColumn extends OracleAlterTableItem {

-    private static final long   serialVersionUID = 1L;
+    private static final long         serialVersionUID = 1L;

-    private SQLColumnDefinition column;
+    private List<SQLColumnDefinition> columns          = new ArrayList<SQLColumnDefinition>();

    @Override
    public void accept0(OracleASTVisitor visitor) {
        if (visitor.visit(this)) {
-            acceptChild(visitor, column);
+            acceptChild(visitor, columns);
        }
        visitor.endVisit(this);
    }

-    public SQLColumnDefinition getColumn() {
-        return column;
+    public List<SQLColumnDefinition> getColumns() {
+        return columns;
    }

-    public void setColumn(SQLColumnDefinition column) {
-        this.column = column;
+    public void setColumns(List<SQLColumnDefinition> columns) {
+        this.columns = columns;
    }

 }
@@ -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 OracleAlterTableMoveTablespace 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;
+    }
+
+}
@@ -8,9 +8,12 @@ import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;

 public class OracleAlterTableStatement extends OracleStatementImpl {

-    private static final long          serialVersionUID = 1L;
+    private static final long          serialVersionUID        = 1L;
    private SQLName                    name;
-    private List<OracleAlterTableItem> items            = new ArrayList<OracleAlterTableItem>();
+    private List<OracleAlterTableItem> items                   = new ArrayList<OracleAlterTableItem>();
+
+    private boolean                    updateGlobalIndexes     = false;
+    private boolean                    invalidateGlobalIndexes = false;

    @Override
    public void accept0(OracleASTVisitor visitor) {
@@ -21,6 +24,22 @@ public class OracleAlterTableStatement extends OracleStatementImpl {
        visitor.endVisit(this);
    }

+    public boolean isUpdateGlobalIndexes() {
+        return updateGlobalIndexes;
+    }
+
+    public void setUpdateGlobalIndexes(boolean updateGlobalIndexes) {
+        this.updateGlobalIndexes = updateGlobalIndexes;
+    }
+
+    public boolean isInvalidateGlobalIndexes() {
+        return invalidateGlobalIndexes;
+    }
+
+    public void setInvalidateGlobalIndexes(boolean invalidateGlobalIndexes) {
+        this.invalidateGlobalIndexes = invalidateGlobalIndexes;
+    }
+
    public SQLName getName() {
        return name;
    }
@@ -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.dialect.oracle.ast.OracleSQLObjectImpl;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleAlterTablespaceAddDataFile extends OracleSQLObjectImpl implements OracleAlterTablespaceItem {
+
+    private static final long             serialVersionUID = 1L;
+
+    private List<OracleFileSpecification> files            = new ArrayList<OracleFileSpecification>();
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, files);
+        }
+        visitor.endVisit(this);
+    }
+
+    public List<OracleFileSpecification> getFiles() {
+        return files;
+    }
+
+    public void setFiles(List<OracleFileSpecification> files) {
+        this.files = files;
+    }
+
+}
@@ -0,0 +1,8 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObject;
+
+
+public interface OracleAlterTablespaceItem extends OracleSQLObject {
+
+}
@@ -0,0 +1,38 @@
+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 OracleAlterTablespaceStatement extends OracleStatementImpl {
+
+    private static final long         serialVersionUID = 1L;
+
+    private SQLName                   name;
+    private OracleAlterTablespaceItem item;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+            acceptChild(visitor, item);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+    public OracleAlterTablespaceItem getItem() {
+        return item;
+    }
+
+    public void setItem(OracleAlterTablespaceItem item) {
+        this.item = item;
+    }
+
+}
@@ -0,0 +1,48 @@
+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 OracleAlterTriggerStatement extends OracleStatementImpl {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLName           name;
+
+    private Boolean           enable;
+
+    private boolean           compile;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+        }
+        visitor.endVisit(this);
+    }
+
+    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 SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+}
@@ -0,0 +1,48 @@
+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 OracleAlterViewStatement extends OracleStatementImpl {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLName           name;
+
+    private Boolean           enable;
+
+    private boolean           compile;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+        }
+        visitor.endVisit(this);
+    }
+
+    public Boolean getEnable() {
+        return enable;
+    }
+
+    public void setEnable(Boolean enable) {
+        this.enable = enable;
+    }
+
+    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;
+    }
+
+}
@@ -3,25 +3,48 @@ package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
 import java.util.ArrayList;
 import java.util.List;

+import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLName;
 import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
 import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;

 public class OracleCreateIndexStatement extends OracleStatementImpl {

-    private static final long          serialVersionUID = 1L;
+    private static final long          serialVersionUID  = 1L;

    private SQLName                    name;

    private SQLName                    table;

-    private List<SQLSelectOrderByItem> items            = new ArrayList<SQLSelectOrderByItem>();
+    private List<SQLSelectOrderByItem> items             = new ArrayList<SQLSelectOrderByItem>();

    private SQLName                    tablespace;

    private Type                       type;

-    private boolean                    online           = false;
+    private boolean                    online            = false;
+
+    private boolean                    indexOnlyTopLevel = false;
+
+    private boolean                    noParallel;
+
+    private SQLExpr                    parallel;
+
+    public SQLExpr getParallel() {
+        return parallel;
+    }
+
+    public void setParallel(SQLExpr parallel) {
+        this.parallel = parallel;
+    }
+
+    public boolean isNoParallel() {
+        return noParallel;
+    }
+
+    public void setNoParallel(boolean noParallel) {
+        this.noParallel = noParallel;
+    }

    public Type getType() {
        return type;
@@ -31,6 +54,14 @@ public class OracleCreateIndexStatement extends OracleStatementImpl {
        this.type = type;
    }

+    public boolean isIndexOnlyTopLevel() {
+        return indexOnlyTopLevel;
+    }
+
+    public void setIndexOnlyTopLevel(boolean indexOnlyTopLevel) {
+        this.indexOnlyTopLevel = indexOnlyTopLevel;
+    }
+
    @Override
    public void accept0(OracleASTVisitor visitor) {
        if (visitor.visit(this)) {
@@ -38,6 +69,7 @@ public class OracleCreateIndexStatement extends OracleStatementImpl {
            acceptChild(visitor, table);
            acceptChild(visitor, items);
            acceptChild(visitor, tablespace);
+            acceptChild(visitor, parallel);
        }
        visitor.endVisit(this);
    }
@@ -12,7 +12,7 @@ import com.alibaba.druid.sql.visitor.SQLASTVisitor;

 public class OracleCreateTableStatement extends SQLCreateTableStatement implements OracleStatement {

-    private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID  = 1L;

    private SQLName           tablespace;

@@ -25,7 +25,17 @@ public class OracleCreateTableStatement extends SQLCreateTableStatement implemen
    // NOPARALLEL
    private Boolean           parallel;

-    private List<StorageItem> storage          = new ArrayList<StorageItem>();
+    private List<StorageItem> storage           = new ArrayList<StorageItem>();
+
+    private boolean           organizationIndex = false;
+
+    public boolean isOrganizationIndex() {
+        return organizationIndex;
+    }
+
+    public void setOrganizationIndex(boolean organizationIndex) {
+        this.organizationIndex = organizationIndex;
+    }

    public Boolean getParallel() {
        return parallel;
@@ -0,0 +1,64 @@
+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.dialect.oracle.ast.OracleSQLObjectImpl;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class OracleFileSpecification extends OracleSQLObjectImpl {
+
+    private static final long serialVersionUID = 1L;
+
+    private List<SQLExpr>     fileNames        = new ArrayList<SQLExpr>();
+
+    private SQLExpr           size;
+
+    private boolean           autoExtendOff    = false;
+
+    private SQLExpr           autoExtendOn;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, fileNames);
+            acceptChild(visitor, size);
+            acceptChild(visitor, autoExtendOn);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLExpr getAutoExtendOn() {
+        return autoExtendOn;
+    }
+
+    public void setAutoExtendOn(SQLExpr autoExtendOn) {
+        this.autoExtendOn = autoExtendOn;
+    }
+
+    public SQLExpr getSize() {
+        return size;
+    }
+
+    public void setSize(SQLExpr size) {
+        this.size = size;
+    }
+
+    public boolean isAutoExtendOff() {
+        return autoExtendOff;
+    }
+
+    public void setAutoExtendOff(boolean autoExtendOff) {
+        this.autoExtendOff = autoExtendOff;
+    }
+
+    public List<SQLExpr> getFileNames() {
+        return fileNames;
+    }
+
+    public void setFileNames(List<SQLExpr> fileNames) {
+        this.fileNames = fileNames;
+    }
+
+}
@@ -6,10 +6,11 @@ import java.util.List;
 import com.alibaba.druid.sql.ast.SQLExpr;
 import com.alibaba.druid.sql.ast.SQLName;
 import com.alibaba.druid.sql.ast.statement.SQLPrimaryKey;
+import com.alibaba.druid.sql.ast.statement.SQLTableElement;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
 import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;

-public class OraclePrimaryKey extends OracleSQLObjectImpl implements SQLPrimaryKey {
+public class OraclePrimaryKey extends OracleSQLObjectImpl implements SQLPrimaryKey, SQLTableElement {

    private static final long serialVersionUID = 1L;

@@ -82,7 +82,9 @@ public class OracleSelectSubqueryTableSource extends SQLSubqueryTableSource impl

    protected void accept0(OracleASTVisitor visitor) {
        if (visitor.visit(this)) {
+            acceptChild(visitor, this.hints);
            acceptChild(visitor, this.select);
+            acceptChild(visitor, this.pivot);
            acceptChild(visitor, this.flashback);
        }
        visitor.endVisit(this);
@@ -31,7 +31,6 @@ public class OracleUpdateStatement extends SQLUpdateStatement implements OracleS
    private final List<OracleHint> hints            = new ArrayList<OracleHint>(1);
    private boolean                only             = false;
    private String                 alias;
-    private OracleUpdateSetClause  setClause;
    private SQLExpr                where;

    public OracleUpdateStatement(){
@@ -75,14 +74,6 @@ public class OracleUpdateStatement extends SQLUpdateStatement implements OracleS
        this.where = where;
    }

-    public OracleUpdateSetClause getSetClause() {
-        return this.setClause;
-    }
-
-    public void setSetClause(OracleUpdateSetClause setClause) {
-        this.setClause = setClause;
-    }
-
    public boolean isOnly() {
        return this.only;
    }
@@ -59,6 +59,11 @@ public class OracleCreateTableParser extends SQLCreateTableParser {
                }
                accept(Token.RPAREN);
                continue;
+            } else if (identifierEquals("organization")) {
+                lexer.nextToken();
+                accept(Token.INDEX);
+                stmt.setOrganizationIndex(true);
+                continue;
            }
            break;
        }
@@ -51,9 +51,11 @@ 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.OracleSizeExpr;
 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;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OraclePrimaryKey;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelect;
 import com.alibaba.druid.sql.parser.Lexer;
 import com.alibaba.druid.sql.parser.ParserException;
@@ -65,6 +67,11 @@ public class OracleExprParser extends SQLExprParser {



+
+
+
+
+
    public boolean                allowStringAdditive = false;

    /**
@@ -266,6 +273,32 @@ public class OracleExprParser extends SQLExprParser {
    }

    public SQLExpr primaryRest(SQLExpr expr) throws ParserException {
+        if (lexer.token() == Token.IDENTIFIER) {
+            String ident = lexer.stringVal();
+            if (ident.length() == 1) {
+                char unit = ident.charAt(0);
+                switch (unit) {
+                    case 'K':
+                    case 'M':
+                    case 'G':
+                    case 'T':
+                    case 'P':
+                    case 'E':
+                    case 'k':
+                    case 'm':
+                    case 'g':
+                    case 't':
+                    case 'p':
+                    case 'e':
+                        expr = new OracleSizeExpr(expr, OracleSizeExpr.Unit.valueOf(ident.toUpperCase()));
+                        lexer.nextToken();
+                        break;
+                    default:
+                    break;
+                }
+            }
+        }
+        
        if (lexer.token() == Token.DOTDOT) {
            lexer.nextToken();
            SQLExpr upBound = expr();
@@ -407,7 +440,7 @@ public class OracleExprParser extends SQLExprParser {
    public SQLExpr parseTimestamp() {
        accept(Token.TIMESTAMP);
        
-        if (lexer.token() != Token.LITERAL_ALIAS) {
+        if (lexer.token() != Token.LITERAL_ALIAS && lexer.token() != Token.LITERAL_CHARS) {
            return new SQLIdentifierExpr("TIMESTAMP");
        }

@@ -731,4 +764,22 @@ public class OracleExprParser extends SQLExprParser {

        return expr;
    }
+    
+    public OraclePrimaryKey parsePrimaryKey() {
+        lexer.nextToken();
+        accept(Token.KEY);
+
+        OraclePrimaryKey primaryKey = new OraclePrimaryKey();
+        accept(Token.LPAREN);
+        exprList(primaryKey.getColumns());
+        accept(Token.RPAREN);
+
+        
+        if (lexer.token() == Token.USING) {
+            lexer.nextToken();
+            accept(Token.INDEX);
+            primaryKey.setUsingIndex(expr());
+        }
+        return primaryKey;
+    }
 }
@@ -31,6 +31,7 @@ import com.alibaba.druid.sql.ast.statement.SQLUnionQuery;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.CycleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfFlashbackQueryClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfSnapshotClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.VersionsFlashbackQueryClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.GroupingSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause;
@@ -824,17 +825,31 @@ public class OracleSelectParser extends SQLSelectParser {
        if (lexer.token() == Token.OF) {
            lexer.nextToken();

-            AsOfFlashbackQueryClause clause = new AsOfFlashbackQueryClause();
+            
            if (identifierEquals("SCN")) {
+                AsOfFlashbackQueryClause clause = new AsOfFlashbackQueryClause();
                clause.setType(AsOfFlashbackQueryClause.Type.SCN);
                lexer.nextToken();
+                clause.setExpr(createExprParser().expr());
+
+                return clause;
+            } else if (identifierEquals("SNAPSHOT")) {
+                lexer.nextToken();
+                accept(Token.LPAREN);
+                AsOfSnapshotClause clause = new AsOfSnapshotClause();
+                clause.setExpr(this.expr());
+                accept(Token.RPAREN);
+                
+                return clause;
            } else {
+                AsOfFlashbackQueryClause clause = new AsOfFlashbackQueryClause();
                accept(Token.TIMESTAMP);
                clause.setType(AsOfFlashbackQueryClause.Type.TIMESTAMP);
+                clause.setExpr(createExprParser().expr());
+                
+                return clause;
            }
-            clause.setExpr(createExprParser().expr());

-            return clause;
        }

        return null;
@@ -25,6 +25,7 @@ import com.alibaba.druid.sql.ast.expr.SQLBinaryOpExpr;
 import com.alibaba.druid.sql.ast.expr.SQLBinaryOperator;
 import com.alibaba.druid.sql.ast.expr.SQLCharExpr;
 import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
+import com.alibaba.druid.sql.ast.statement.SQLConstaint;
 import com.alibaba.druid.sql.ast.statement.SQLInsertInto;
 import com.alibaba.druid.sql.ast.statement.SQLSelect;
 import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
@@ -39,11 +40,13 @@ 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.OracleAlterSynonymStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddConstaint;
 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.OracleAlterTableMoveTablespace;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableRenameTo;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.NestedTablePartitionSpec;
@@ -51,6 +54,10 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartit
 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.OracleAlterTablespaceAddDataFile;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTablespaceStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTriggerStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterViewStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
@@ -58,6 +65,7 @@ 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.OracleFileSpecification;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGotoStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
@@ -69,7 +77,6 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleLockTableStatement.Lo
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMergeStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OraclePLSQLCommitStatement;
-import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OraclePrimaryKey;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSetTransactionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleStatement;
 import com.alibaba.druid.sql.parser.Lexer;
@@ -277,7 +284,7 @@ public class OracleStatementParser extends SQLStatementParser {
                statementList.add(this.parseIf());
                continue;
            }
-            
+
            if (lexer.token() == Token.GOTO) {
                lexer.nextToken();
                SQLName label = this.exprParser.name();
@@ -285,10 +292,10 @@ public class OracleStatementParser extends SQLStatementParser {
                statementList.add(stmt);
                continue;
            }
-            
+
            if (lexer.token() == Token.COMMIT) {
                lexer.nextToken();
-                
+
                if (identifierEquals("WORK")) {
                    lexer.nextToken();
                }
@@ -296,7 +303,7 @@ public class OracleStatementParser extends SQLStatementParser {
                statementList.add(stmt);
                continue;
            }
-            
+
            if (lexer.token() == Token.LTLT) {
                lexer.nextToken();
                SQLName label = this.exprParser.name();
@@ -305,8 +312,6 @@ public class OracleStatementParser extends SQLStatementParser {
                statementList.add(stmt);
                continue;
            }
-            
-            

            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
        }
@@ -468,17 +473,160 @@ public class OracleStatementParser extends SQLStatementParser {
            OracleAlterIndexStatement stmt = new OracleAlterIndexStatement();
            stmt.setName(this.exprParser.name());

-            if (identifierEquals("rebuild")) {
-                lexer.nextToken();
+            for (;;) {
+                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);
+                    OracleAlterIndexStatement.Rebuild rebuild = new OracleAlterIndexStatement.Rebuild();
+                    stmt.setRebuild(rebuild);
+                    continue;
+                } else if (identifierEquals("MONITORING")) {
+                    lexer.nextToken();
+                    acceptIdentifier("USAGE");
+                    stmt.setMonitoringUsage(Boolean.TRUE);
+                    continue;
+                } else if (identifierEquals("PARALLEL")) {
+                    lexer.nextToken();
+                    stmt.setParallel(this.exprParser.expr());
+                }
+                break;
            }

+            return stmt;
+        } else if (identifierEquals("TRIGGER")) {
+            lexer.nextToken();
+            OracleAlterTriggerStatement stmt = new OracleAlterTriggerStatement();
+            stmt.setName(this.exprParser.name());
+
+            for (;;) {
+                if (identifierEquals("ENABLE")) {
+                    lexer.nextToken();
+                    stmt.setEnable(Boolean.TRUE);
+                    continue;
+                } else if (identifierEquals("DISABLE")) {
+                    lexer.nextToken();
+                    stmt.setEnable(Boolean.FALSE);
+                    continue;
+                } else if (identifierEquals("COMPILE")) {
+                    lexer.nextToken();
+                    stmt.setCompile(true);
+                    continue;
+                }
+                break;
+            }
+
+            return stmt;
+        } else if (identifierEquals("SYNONYM")) {
+            lexer.nextToken();
+            OracleAlterSynonymStatement stmt = new OracleAlterSynonymStatement();
+            stmt.setName(this.exprParser.name());
+
+            for (;;) {
+                if (identifierEquals("ENABLE")) {
+                    lexer.nextToken();
+                    stmt.setEnable(Boolean.TRUE);
+                    continue;
+                } else if (identifierEquals("DISABLE")) {
+                    lexer.nextToken();
+                    stmt.setEnable(Boolean.FALSE);
+                    continue;
+                } else if (identifierEquals("COMPILE")) {
+                    lexer.nextToken();
+                    stmt.setCompile(true);
+                    continue;
+                }
+                break;
+            }
+
+            return stmt;
+        } else if (lexer.token() == Token.VIEW) {
+            lexer.nextToken();
+            OracleAlterViewStatement stmt = new OracleAlterViewStatement();
+            stmt.setName(this.exprParser.name());
+
+            for (;;) {
+                if (identifierEquals("ENABLE")) {
+                    lexer.nextToken();
+                    stmt.setEnable(Boolean.TRUE);
+                    continue;
+                } else if (identifierEquals("DISABLE")) {
+                    lexer.nextToken();
+                    stmt.setEnable(Boolean.FALSE);
+                    continue;
+                } else if (identifierEquals("COMPILE")) {
+                    lexer.nextToken();
+                    stmt.setCompile(true);
+                    continue;
+                }
+                break;
+            }
+
+            return stmt;
+        } else if (identifierEquals("TABLESPACE")) {
+            lexer.nextToken();
+
+            OracleAlterTablespaceStatement stmt = new OracleAlterTablespaceStatement();
+            stmt.setName(this.exprParser.name());
+
+            if (identifierEquals("ADD")) {
+                lexer.nextToken();
+                
+                if (identifierEquals("DATAFILE")) {
+                    lexer.nextToken();
+                    
+                    OracleAlterTablespaceAddDataFile item = new OracleAlterTablespaceAddDataFile();
+                    
+                    for (;;) {
+                        OracleFileSpecification file = new OracleFileSpecification();
+                        
+                        for (;;) {
+                            SQLExpr fileName = this.exprParser.expr();
+                            file.getFileNames().add(fileName);
+                            
+                            if (lexer.token() == Token.COMMA) {
+                                lexer.nextToken();
+                                continue;
+                            }
+                            
+                            break;
+                        }
+                        
+                        if (identifierEquals("SIZE")) {
+                            lexer.nextToken();
+                            file.setSize(this.exprParser.expr());
+                        }
+                        
+                        if (identifierEquals("AUTOEXTEND")) {
+                            lexer.nextToken();
+                            if (identifierEquals("OFF")) {
+                                lexer.nextToken();
+                                file.setAutoExtendOff(true);
+                            } else if (identifierEquals("ON")) {
+                                lexer.nextToken();
+                                file.setAutoExtendOn(this.exprParser.expr());
+                            } else {
+                                throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                            }
+                        }
+                        
+                        item.getFiles().add(file);
+                        
+                        if (lexer.token() == Token.COMMA) {
+                            lexer.nextToken();
+                            continue;
+                        }
+                        
+                        break;
+                    }
+                    
+                    stmt.setItem(item);
+                } else {
+                    throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                }
+            } else {
+                throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+            }
+            
            return stmt;
        }

@@ -496,11 +644,19 @@ public class OracleStatementParser extends SQLStatementParser {

                if (lexer.token() == Token.LPAREN) {
                    lexer.nextToken();
-                    SQLColumnDefinition columnDef = this.exprParser.parseColumn();
-                    accept(Token.RPAREN);

                    OracleAlterTableAddColumn item = new OracleAlterTableAddColumn();
-                    item.setColumn(columnDef);
+
+                    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 if (lexer.token() == Token.CONSTRAINT) {
@@ -511,7 +667,18 @@ public class OracleStatementParser extends SQLStatementParser {

                continue;
            } else if (identifierEquals("MOVE")) {
-                throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                lexer.nextToken();
+
+                if (identifierEquals("TABLESPACE")) {
+                    lexer.nextToken();
+
+                    OracleAlterTableMoveTablespace item = new OracleAlterTableMoveTablespace();
+                    item.setName(this.exprParser.name());
+
+                    stmt.getItems().add(item);
+                } else {
+                    throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                }
            } else if (identifierEquals("RENAME")) {
                stmt.getItems().add(parseAlterTableRename());
            } else if (identifierEquals("MODIFY")) {
@@ -559,12 +726,24 @@ public class OracleStatementParser extends SQLStatementParser {
            break;
        }

+        if (lexer.token() == Token.UPDATE) {
+            lexer.nextToken();
+
+            if (identifierEquals("GLOBAL")) {
+                lexer.nextToken();
+                acceptIdentifier("INDEXES");
+                stmt.setUpdateGlobalIndexes(true);
+            } else {
+                throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+            }
+        }
+
        return stmt;
    }

    private OracleAlterTableItem parseAlterTableRename() {
        acceptIdentifier("RENAME");
-        
+
        if (lexer.token() == Token.TO) {
            lexer.nextToken();
            OracleAlterTableRenameTo item = new OracleAlterTableRenameTo();
@@ -581,30 +760,18 @@ public class OracleStatementParser extends SQLStatementParser {

        SQLName name = this.exprParser.name();

+        SQLConstaint constraint;
        if (lexer.token() == Token.PRIMARY) {
-            lexer.nextToken();
-            accept(Token.KEY);
-
-            OraclePrimaryKey primaryKey = new OraclePrimaryKey();
-            accept(Token.LPAREN);
-            this.exprParser.exprList(primaryKey.getColumns());
-            accept(Token.RPAREN);
-
-            item.setConstraint(primaryKey);
-            if (lexer.token() == Token.USING) {
-                lexer.nextToken();
-                accept(Token.INDEX);
-                primaryKey.setUsingIndex(this.exprParser.expr());
-            }
-
-            primaryKey.setName(name);
-
-            item.setConstraint(primaryKey);
-
-            return item;
+            constraint = exprParser.parsePrimaryKey();
+        } else {
+            throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
        }

-        throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+        constraint.setName(name);
+
+        item.setConstraint(constraint);
+
+        return item;
    }

    private void parseAlterTableDrop(OracleAlterTableStatement stmt) {
@@ -731,7 +898,7 @@ public class OracleStatementParser extends SQLStatementParser {
                OracleParameter parameter = new OracleParameter();
                parameter.setName(this.exprParser.name());
                parameter.setDataType(this.exprParser.parseDataType());
-                
+
                block.getParameters().add(parameter);

                if (lexer.token() == Token.COLONEQ) {
@@ -757,6 +924,10 @@ public class OracleStatementParser extends SQLStatementParser {
        return block;
    }

+    public OracleSelectParser createSQLSelectParser() {
+        return new OracleSelectParser(this.lexer);
+    }
+
    public OracleMergeStatement parseMerge() throws ParserException {
        accept(Token.MERGE);

@@ -1106,7 +1277,7 @@ public class OracleStatementParser extends SQLStatementParser {
        }

        OracleCreateIndexStatement stmt = new OracleCreateIndexStatement();
-        if (lexer.token() == Token.UNION) {
+        if (lexer.token() == Token.UNIQUE) {
            stmt.setType(OracleCreateIndexStatement.Type.UNIQUE);
            lexer.nextToken();
        } else if (identifierEquals("BITMAP")) {
@@ -1144,6 +1315,20 @@ public class OracleStatementParser extends SQLStatementParser {
                lexer.nextToken();
                stmt.setOnline(true);
                continue;
+            } else if (identifierEquals("NOPARALLEL")) {
+                lexer.nextToken();
+                stmt.setNoParallel(true);
+                continue;
+            } else if (identifierEquals("PARALLEL")) {
+                lexer.nextToken();
+                stmt.setParallel(this.exprParser.expr());
+                continue;
+            } else if (lexer.token() == Token.INDEX) {
+                lexer.nextToken();
+                acceptIdentifier("ONLY");
+                acceptIdentifier("TOPLEVEL");
+                stmt.setIndexOnlyTopLevel(true);
+                continue;
            } else {
                break;
            }
@@ -5,6 +5,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.OracleHint;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleOrderBy;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.CycleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfFlashbackQueryClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfSnapshotClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.VersionsFlashbackQueryClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.GroupingSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause;
@@ -40,19 +41,26 @@ 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.OracleSizeExpr;
 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.OracleAlterSynonymStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddConstaint;
 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.OracleAlterTableMoveTablespace;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableRenameTo;
 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.OracleAlterTablespaceAddDataFile;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTablespaceStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTriggerStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterViewStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
@@ -62,6 +70,7 @@ 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.OracleFileSpecification;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGotoStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
@@ -942,15 +951,15 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora
    public void endVisit(OracleAlterTableDropPartition x) {

    }
-    
+
    @Override
    public boolean visit(OracleAlterTableTruncatePartition x) {
        return true;
    }
-    
+
    @Override
    public void endVisit(OracleAlterTableTruncatePartition x) {
-        
+
    }

    @Override
@@ -962,35 +971,35 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora
    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
@@ -1000,67 +1009,67 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora

    @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
@@ -1070,77 +1079,77 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora

    @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) {
-        
+
    }
-    
+
    @Override
    public boolean visit(OracleAlterTableAddConstaint x) {
        return true;
    }
-    
+
    @Override
    public void endVisit(OracleAlterTableAddConstaint x) {
-        
+
    }
-    
+
    @Override
    public boolean visit(OraclePrimaryKey x) {
        return true;
    }
-    
+
    @Override
    public void endVisit(OraclePrimaryKey x) {
-        
+
    }
-    
+
    @Override
    public boolean visit(OracleCreateTableStatement x) {
        return true;
    }
-    
+
    @Override
    public void endVisit(OracleCreateTableStatement x) {
-        
+
    }
-    
+
    @Override
    public boolean visit(OracleAlterTableRenameTo x) {
        return true;
    }
-    
+
    @Override
    public void endVisit(OracleAlterTableRenameTo x) {
-        
+
    }

    @Override
@@ -1150,7 +1159,7 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora

    @Override
    public void endVisit(StorageItem x) {
-        
+
    }

    @Override
@@ -1160,17 +1169,17 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora

    @Override
    public void endVisit(OracleGotoStatement x) {
-        
+
    }
-    
+
    @Override
    public boolean visit(OracleLabelStatement x) {
        return true;
    }
-    
+
    @Override
    public void endVisit(OracleLabelStatement x) {
-        
+
    }

    @Override
@@ -1180,16 +1189,106 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora

    @Override
    public void endVisit(OracleParameter x) {
-        
+
    }
-    
+
    @Override
    public boolean visit(OracleCommitStatement x) {
        return true;
    }
-    
+
    @Override
    public void endVisit(OracleCommitStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTriggerStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTriggerStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterSynonymStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleAlterSynonymStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(AsOfSnapshotClause x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(AsOfSnapshotClause x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterViewStatement x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleAlterViewStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableMoveTablespace x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableMoveTablespace x) {
+
+    }
+    
+    @Override
+    public boolean visit(OracleSizeExpr x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleSizeExpr x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleFileSpecification x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleFileSpecification x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleAlterTablespaceAddDataFile x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterTablespaceAddDataFile x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleAlterTablespaceStatement x) {
+        return true;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterTablespaceStatement x) {
        
    }

@@ -20,6 +20,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.OracleHint;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleOrderBy;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.CycleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfFlashbackQueryClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfSnapshotClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.VersionsFlashbackQueryClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.GroupingSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause;
@@ -46,19 +47,26 @@ 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.OracleSizeExpr;
 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.OracleAlterSynonymStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddConstaint;
 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.OracleAlterTableMoveTablespace;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableRenameTo;
 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.OracleAlterTablespaceAddDataFile;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTablespaceStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTriggerStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterViewStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
@@ -68,6 +76,7 @@ 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.OracleFileSpecification;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGotoStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
@@ -525,4 +534,40 @@ public interface OracleASTVisitor extends SQLASTVisitor {
    boolean visit(OracleCommitStatement x);
    
    void endVisit(OracleCommitStatement x);
+    
+    boolean visit(OracleAlterTriggerStatement x);
+    
+    void endVisit(OracleAlterTriggerStatement x);
+    
+    boolean visit(OracleAlterSynonymStatement x);
+    
+    void endVisit(OracleAlterSynonymStatement x);
+    
+    boolean visit(OracleAlterViewStatement x);
+    
+    void endVisit(OracleAlterViewStatement x);
+    
+    boolean visit(AsOfSnapshotClause x);
+    
+    void endVisit(AsOfSnapshotClause x);
+    
+    boolean visit(OracleAlterTableMoveTablespace x);
+    
+    void endVisit(OracleAlterTableMoveTablespace x);
+    
+    boolean visit(OracleSizeExpr x);
+    
+    void endVisit(OracleSizeExpr x);
+    
+    boolean visit(OracleFileSpecification x);
+    
+    void endVisit(OracleFileSpecification x);
+    
+    boolean visit(OracleAlterTablespaceAddDataFile x);
+    
+    void endVisit(OracleAlterTablespaceAddDataFile x);
+    
+    boolean visit(OracleAlterTablespaceStatement x);
+    
+    void endVisit(OracleAlterTablespaceStatement x);
 }
@@ -38,6 +38,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.OracleHint;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleOrderBy;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.CycleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfFlashbackQueryClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfSnapshotClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.VersionsFlashbackQueryClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.GroupingSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause;
@@ -75,17 +76,20 @@ 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.OracleSizeExpr;
 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.OracleAlterSynonymStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddConstaint;
 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.OracleAlterTableMoveTablespace;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableRenameTo;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.NestedTablePartitionSpec;
@@ -93,6 +97,10 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartit
 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.OracleAlterTablespaceAddDataFile;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTablespaceStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTriggerStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterViewStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
@@ -102,6 +110,7 @@ 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.OracleFileSpecification;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGotoStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
@@ -1976,6 +1985,10 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
            println();
            item.accept(this);
        }
+        if (x.isUpdateGlobalIndexes()) {
+            println();
+            print("UPDATE GLOABL INDEXES");
+        }
        decrementIndent();
        return false;
    }
@@ -2105,7 +2118,7 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
    @Override
    public boolean visit(OracleAlterTableAddColumn x) {
        print("ADD (");
-        x.getColumn().accept(this);
+        printAndAccept(x.getColumns(), ", ");
        print(")");
        return false;
    }
@@ -2129,6 +2142,11 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
        print("(");
        printAndAccept(x.getItems(), ", ");
        print(")");
+        
+        if (x.isIndexOnlyTopLevel()) {
+            print(" INDEX ONLY TOPLEVEL");
+        }
+        
        if (x.getTablespace() != null) {
            print(" TABLESPACE ");
            x.getTablespace().accept(this);
@@ -2137,6 +2155,13 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
        if (x.isOnline()) {
            print(" ONLINE");
        }
+        
+        if (x.isNoParallel()) {
+            print(" NOPARALLEL");
+        } else if (x.getParallel() != null){
+            print(" PARALLEL ");
+            x.getParallel().accept(this);
+        }
        return false;
    }

@@ -2158,6 +2183,11 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
            print(" ");
            x.getRebuild().accept(this);
        }
+        
+        if (x.getParallel() != null) {
+            print(" PARALLEL");
+            x.getParallel().accept(this);
+        }

        return false;
    }
@@ -2361,6 +2391,11 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
        this.visit((SQLCreateTableStatement) x);

        incrementIndent();
+        
+        if (x.isOrganizationIndex()) {
+            print(" ORGANIZATION INDEX");
+        }
+        
        if (x.getTablespace() != null) {
            print(" TABLESPACE ");
            x.getTablespace().accept(this);
@@ -2480,4 +2515,167 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
    public void endVisit(OracleCommitStatement x) {
        
    }
+
+    @Override
+    public boolean visit(OracleAlterTriggerStatement x) {
+        print("ALTER TRIGGER ");
+        x.getName().accept(this);
+       
+        if (x.isCompile()) {
+            print(" COMPILE");
+        }
+        
+        if (x.getEnable() != null) {
+            if (x.getEnable().booleanValue()) {
+                print("ENABLE");
+            } else {
+                print("DISABLE");
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTriggerStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterSynonymStatement x) {
+        print("ALTER SYNONYM ");
+        x.getName().accept(this);
+        
+        if (x.isCompile()) {
+            print(" COMPILE");
+        }
+        
+        if (x.getEnable() != null) {
+            if (x.getEnable().booleanValue()) {
+                print("ENABLE");
+            } else {
+                print("DISABLE");
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterSynonymStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(AsOfSnapshotClause x) {
+        print("AS OF SNAPSHOT(");
+        x.getExpr().accept(this);
+        print(")");
+        return false;
+    }
+
+    @Override
+    public void endVisit(AsOfSnapshotClause x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterViewStatement x) {
+        print("ALTER VIEW ");
+        x.getName().accept(this);
+        
+        if (x.isCompile()) {
+            print(" COMPILE");
+        }
+        
+        if (x.getEnable() != null) {
+            if (x.getEnable().booleanValue()) {
+                print("ENABLE");
+            } else {
+                print("DISABLE");
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterViewStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableMoveTablespace x) {
+        print(" MOVE TABLESPACE ");
+        x.getName().accept(this);
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableMoveTablespace x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleSizeExpr x) {
+        x.getValue().accept(this);
+        print(x.getUnit().name());
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleSizeExpr x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleFileSpecification x) {
+        printAndAccept(x.getFileNames(), ", ");
+        
+        if (x.getSize() != null) {
+            print(" SIZE ");
+            x.getSize().accept(this);
+        }
+        
+        if (x.isAutoExtendOff()) {
+            print(" AUTOEXTEND OFF");
+        } else if (x.getAutoExtendOn() != null) {
+            print(" AUTOEXTEND ON ");
+            x.getAutoExtendOn().accept(this);
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleFileSpecification x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterTablespaceAddDataFile x) {
+        print("ADD DATAFILE");
+        incrementIndent();
+        for (OracleFileSpecification file : x.getFiles()) {
+            println();
+            file.accept(this);
+        }
+        decrementIndent();
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTablespaceAddDataFile x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterTablespaceStatement x) {
+        print("ALTER TABLESPACE ");
+        x.getName().accept(this);
+        println();
+        x.getItem().accept(this);
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTablespaceStatement x) {
+        
+    }
 }
@@ -11,6 +11,7 @@ import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr;
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.alibaba.druid.sql.ast.expr.SQLObjectCreateExpr;
 import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
+import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
 import com.alibaba.druid.sql.ast.statement.SQLDeleteStatement;
 import com.alibaba.druid.sql.ast.statement.SQLExprTableSource;
@@ -22,6 +23,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.OracleHint;
 import com.alibaba.druid.sql.dialect.oracle.ast.OracleOrderBy;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.CycleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfFlashbackQueryClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.AsOfSnapshotClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.FlashbackQueryClause.VersionsFlashbackQueryClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.GroupingSetExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.ModelClause;
@@ -57,19 +59,26 @@ 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.OracleSizeExpr;
 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.OracleAlterSynonymStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddConstaint;
 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.OracleAlterTableMoveTablespace;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableRenameTo;
 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.OracleAlterTablespaceAddDataFile;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTablespaceStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTriggerStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterViewStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCommitStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
@@ -79,6 +88,7 @@ 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.OracleFileSpecification;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleForStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGotoStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleGrantStatement;
@@ -125,6 +135,10 @@ import com.alibaba.druid.stat.TableStat.Relationship;

 public class OracleSchemaStatVisitor extends SchemaStatVisitor implements OracleASTVisitor {

+    public OracleSchemaStatVisitor(){
+        this.aliasMap.put("DUAL", null);
+    }
+
    protected Column getColumn(SQLExpr expr) {
        if (expr instanceof OracleOuterExpr) {
            expr = ((OracleOuterExpr) expr).getExpr();
@@ -167,12 +181,9 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
                return false;
            }

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-                x.putAttribute(ATTR_TABLE, ident);
-            }
+            x.putAttribute(ATTR_TABLE, ident);
+
+            TableStat stat = getTableStat(ident);

            Mode mode = getMode();
            switch (mode) {
@@ -221,9 +232,12 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
    }

    public void endVisit(OracleSelect x) {
+        endVisit((SQLSelect) x);
    }

    public boolean visit(OracleSelect x) {
+        setCurrentTable(x);
+
        if (x.getOrderBy() != null) {
            x.getOrderBy().setParent(x);
        }
@@ -239,6 +253,12 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
    }

    public void endVisit(SQLSelect x) {
+        if (x.getQuery() != null) {
+            String table = (String) x.getQuery().getAttribute(ATTR_TABLE);
+            if (table != null) {
+                x.putAttribute(ATTR_TABLE, table);
+            }
+        }
        restoreCurrentTable(x);
    }

@@ -253,24 +273,21 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
            tableExpr = ((SQLExprTableSource) tableSource).getExpr();
        }

-        if (tableExpr instanceof SQLIdentifierExpr) {
+        if (tableExpr instanceof SQLName) {
            String ident = tableExpr.toString();
            setCurrentTable(ident);

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-            }
+            TableStat stat = getTableStat(ident);
            stat.incrementUpdateCount();

            Map<String, String> aliasMap = getAliasMap();
            aliasMap.put(ident, ident);
+            aliasMap.put(tableSource.getAlias(), ident);
        } else {
            tableSource.accept(this);
        }

-        accept(x.getSetClause());
+        accept(x.getItems());
        accept(x.getWhere());

        return false;
@@ -293,7 +310,16 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
            x.getWhere().setParent(x);
        }

-        return visit((SQLSelectQueryBlock) x);
+        visit((SQLSelectQueryBlock) x);
+
+        if (x.getInto() instanceof SQLName) {
+            TableStat stat = getTableStat(x.getInto().toString());
+            if (stat != null) {
+                stat.incrementInsertCount();
+            }
+        }
+
+        return true;
    }

    public void endVisit(OracleSelectQueryBlock x) {
@@ -565,6 +591,14 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
    public boolean visit(OracleSelectJoin x) {
        x.getLeft().accept(this);
        x.getRight().accept(this);
+
+        {
+            String leftTable = (String) x.getLeft().getAttribute(ATTR_TABLE);
+            String rightTable = (String) x.getRight().getAttribute(ATTR_TABLE);
+            if (leftTable != null && leftTable.equals(rightTable)) {
+                x.putAttribute(ATTR_TABLE, leftTable);
+            }
+        }
        if (x.getCondition() != null) {
            x.getCondition().accept(this);
        }
@@ -583,11 +617,11 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
                }

                if (leftTable != null) {
-                    columns.add(new Column(leftTable, columnName));
+                    addColumn(leftTable, columnName);
                }

                if (rightTable != null) {
-                    columns.add(new Column(rightTable, columnName));
+                    addColumn(rightTable, columnName);
                }
            }
        }
@@ -627,8 +661,23 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public boolean visit(OracleSelectSubqueryTableSource x) {
+        accept(x.getSelect());
+        accept(x.getPivot());
+        accept(x.getFlashback());

-        return true;
+        String table = (String) x.getSelect().getAttribute(ATTR_TABLE);
+        if (x.getAlias() != null) {
+            if (table != null) {
+                this.aliasMap.put(x.getAlias(), table);
+            }
+            this.subQueryMap.put(x.getAlias(), x.getSelect());
+            this.setCurrentTable(x.getAlias());
+        }
+
+        if (table != null) {
+            x.putAttribute(ATTR_TABLE, table);
+        }
+        return false;
    }

    @Override
@@ -935,21 +984,18 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
    public boolean visit(OracleMergeStatement x) {
        setAliasMap();

-        setMode(x, Mode.Merge);
-
        String originalTable = getCurrentTable();

+        setMode(x.getUsing(), Mode.Select);
        x.getUsing().accept(this);

+        setMode(x, Mode.Merge);
+
        String ident = x.getInto().toString();
        setCurrentTable(x, ident);
        x.putAttribute("_old_local_", originalTable);

-        TableStat stat = tableStats.get(ident);
-        if (stat == null) {
-            stat = new TableStat();
-            tableStats.put(new TableStat.Name(ident), stat);
-        }
+        TableStat stat = getTableStat(ident);
        stat.incrementMergeCount();

        Map<String, String> aliasMap = getAliasMap();
@@ -1035,11 +1081,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
            String ident = ((SQLName) x.getTableName()).toString();
            setCurrentTable(x, ident);

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-            }
+            TableStat stat = getTableStat(ident);
            stat.incrementInsertCount();

            Map<String, String> aliasMap = getAliasMap();
@@ -1131,7 +1173,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
    public boolean visit(OracleBlockStatement x) {
        for (OracleParameter param : x.getParameters()) {
            param.setParent(x);
-            
+
            SQLExpr name = param.getName();
            this.variants.put(name.toString(), name);
        }
@@ -1166,8 +1208,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
    @Override
    public boolean visit(OracleLockTableStatement x) {
        String tableName = x.getTable().toString();
-        TableStat stat = new TableStat();
-        this.tableStats.put(new TableStat.Name(tableName), stat);
+        getTableStat(tableName);
        return false;
    }

@@ -1289,18 +1330,22 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
    @Override
    public boolean visit(OracleAlterTableStatement x) {
        String tableName = x.getName().toString();
-        TableStat stat = new TableStat();
+        TableStat stat = getTableStat(tableName);
        stat.incrementAlterCount();
-        this.tableStats.put(new TableStat.Name(tableName), stat);

-        accept(x.getItems());
+        setCurrentTable(x, tableName);
+
+        for (SQLObject item : x.getItems()) {
+            item.setParent(x);
+            item.accept(this);
+        }

        return false;
    }

    @Override
    public void endVisit(OracleAlterTableStatement x) {
-
+        restoreCurrentTable(x);
    }

    @Override
@@ -1345,6 +1390,15 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public boolean visit(OracleAlterTableModify x) {
+        OracleAlterTableStatement stmt = (OracleAlterTableStatement) x.getParent();
+        String table = stmt.getName().toString();
+
+        for (SQLColumnDefinition column : x.getColumns()) {
+            String columnName = column.getName().toString();
+            addColumn(table, columnName);
+
+        }
+
        return false;
    }

@@ -1355,6 +1409,13 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public boolean visit(OracleAlterTableAddColumn x) {
+        OracleAlterTableStatement stmt = (OracleAlterTableStatement) x.getParent();
+        String table = stmt.getName().toString();
+
+        for (SQLColumnDefinition column : x.getColumns()) {
+            String columnName = column.getName().toString();
+            addColumn(table, columnName);
+        }
        return false;
    }

@@ -1365,12 +1426,22 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public boolean visit(OracleCreateIndexStatement x) {
+        this.setCurrentTable(x);
+        if (x.getTable() != null) {
+            String tableName = x.getTable().toString();
+
+            TableStat stat = this.getTableStat(tableName);
+            stat.incrementCreateIndexCount();
+            this.setCurrentTable(tableName);
+
+            accept(x.getItems());
+        }
        return false;
    }

    @Override
    public void endVisit(OracleCreateIndexStatement x) {
-
+        restoreCurrentTable(x);
    }

    @Override
@@ -1382,23 +1453,23 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
    public void endVisit(OracleAlterIndexStatement x) {

    }
-    
+
    @Override
    public boolean visit(OracleForStatement x) {
        x.getRange().setParent(x);
-        
+
        SQLName index = x.getIndex();
        this.getVariants().put(index.toString(), x);
-        
+
        x.getRange().accept(this);
        accept(x.getStatements());
-        
+
        return false;
    }
-    
+
    @Override
    public void endVisit(OracleForStatement x) {
-        
+
    }

    @Override
@@ -1418,27 +1489,27 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @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
@@ -1448,35 +1519,43 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public void endVisit(OracleRangeExpr x) {
-        
+
    }
-    
+
    @Override
    public boolean visit(OracleAlterTableAddConstaint x) {
+        x.getConstraint().accept(this);
        return false;
    }
-    
+
    @Override
    public void endVisit(OracleAlterTableAddConstaint x) {
-        
+
    }

    @Override
    public boolean visit(OraclePrimaryKey x) {
+        accept(x.getColumns());
+
        return false;
    }

    @Override
    public void endVisit(OraclePrimaryKey x) {
-        
+
    }
-    
+
    @Override
    public boolean visit(OracleCreateTableStatement x) {
        this.visit((SQLCreateTableStatement) x);
+
+        if (x.getSelect() != null) {
+            x.getSelect().accept(this);
+        }
+
        return false;
    }
-    
+
    @Override
    public void endVisit(OracleCreateTableStatement x) {
        this.endVisit((SQLCreateTableStatement) x);
@@ -1489,7 +1568,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public void endVisit(OracleAlterTableRenameTo x) {
-        
+
    }

    @Override
@@ -1499,7 +1578,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public void endVisit(StorageItem x) {
-        
+
    }

    @Override
@@ -1509,17 +1588,17 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public void endVisit(OracleGotoStatement x) {
-        
+
    }
-    
+
    @Override
    public boolean visit(OracleLabelStatement x) {
        return false;
    }
-    
+
    @Override
    public void endVisit(OracleLabelStatement x) {
-        
+
    }

    @Override
@@ -1529,7 +1608,7 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public void endVisit(OracleParameter x) {
-        
+
    }

    @Override
@@ -1539,6 +1618,95 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle

    @Override
    public void endVisit(OracleCommitStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTriggerStatement x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTriggerStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterSynonymStatement x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterSynonymStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(AsOfSnapshotClause x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(AsOfSnapshotClause x) {
+
+    }
+    
+    @Override
+    public boolean visit(OracleAlterViewStatement x) {
+        return false;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterViewStatement x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableMoveTablespace x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableMoveTablespace x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleSizeExpr x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleSizeExpr x) {
+        
+    }
+    @Override
+    public boolean visit(OracleFileSpecification x) {
+        return false;
+    }
+    
+    @Override
+    public void endVisit(OracleFileSpecification x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterTablespaceAddDataFile x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTablespaceAddDataFile x) {
+        
+    }
+
+    @Override
+    public boolean visit(OracleAlterTablespaceStatement x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTablespaceStatement x) {
        
    }
 }
@@ -97,11 +97,7 @@ public class PGSchemaStatVisitor extends SchemaStatVisitor implements PGASTVisit
    public boolean visit(IntoClause x) {
        String ident = x.getTable().toString();

-        TableStat stat = tableStats.get(ident);
-        if (stat == null) {
-            stat = new TableStat();
-            tableStats.put(new TableStat.Name(ident), stat);
-        }
+        TableStat stat = getTableStat(ident);
        stat.incrementInsertCount();
        return false;
    }
@@ -133,11 +129,7 @@ public class PGSchemaStatVisitor extends SchemaStatVisitor implements PGASTVisit
        for (SQLName name : x.getUsing()) {
            String ident = name.toString();

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-            }
+            TableStat stat = getTableStat(ident);
            stat.incrementSelectCount();

            Map<String, String> aliasMap = getAliasMap();
@@ -152,14 +144,7 @@ public class PGSchemaStatVisitor extends SchemaStatVisitor implements PGASTVisit
        String ident = ((SQLIdentifierExpr) x.getTableName()).getName();
        setCurrentTable(ident);

-        TableStat stat = tableStats.get(ident);
-        if (stat == null) {
-            stat = new TableStat();
-            tableStats.put(new TableStat.Name(ident), stat);
-            if (x.getAlias() != null) {
-                tableStats.put(new TableStat.Name(x.getAlias()), stat);
-            }
-        }
+        TableStat stat = getTableStat(ident, x.getAlias());
        stat.incrementDeleteCount();

        accept(x.getWhere());
@@ -200,11 +185,7 @@ public class PGSchemaStatVisitor extends SchemaStatVisitor implements PGASTVisit
            setCurrentTable(ident);
            x.putAttribute("_old_local_", originalTable);

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-            }
+            TableStat stat = getTableStat(ident);
            stat.incrementInsertCount();

            Map<String, String> aliasMap = getAliasMap();
@@ -254,11 +235,7 @@ public class PGSchemaStatVisitor extends SchemaStatVisitor implements PGASTVisit
        String ident = x.getTableName().toString();
        setCurrentTable(ident);

-        TableStat stat = tableStats.get(ident);
-        if (stat == null) {
-            stat = new TableStat();
-            tableStats.put(new TableStat.Name(ident), stat);
-        }
+        TableStat stat = getTableStat(ident);
        stat.incrementUpdateCount();

        Map<String, String> aliasMap = getAliasMap();
@@ -17,6 +17,7 @@ package com.alibaba.druid.sql.parser;

 import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
 import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
+import com.alibaba.druid.sql.ast.statement.SQLPrimaryKey;

 public class SQLCreateTableParser extends SQLDDLParser {

@@ -65,17 +66,23 @@ public class SQLCreateTableParser extends SQLDDLParser {
        if (lexer.token() == Token.LPAREN) {
            lexer.nextToken();

-            while (lexer.token() == Token.IDENTIFIER || lexer.token() == Token.LITERAL_ALIAS) {
-                SQLColumnDefinition column = this.exprParser.parseColumn();
-                createTable.getTableElementList().add(column);
-
-                // parseConstaint(column.getConstaints());
-
-                if (lexer.token() != Token.COMMA) {
-                    break;
+            for (;;) {
+                if (lexer.token() == Token.IDENTIFIER || lexer.token() == Token.LITERAL_ALIAS) {
+                    SQLColumnDefinition column = this.exprParser.parseColumn();
+                    createTable.getTableElementList().add(column);
+                } else if (lexer.token() == Token.PRIMARY) {
+                    SQLPrimaryKey primaryKey = exprParser.parsePrimaryKey();
+                    createTable.getTableElementList().add(primaryKey);
+                } else {
+                    throw new ParserException("TODO " + lexer.token());
+                }
+                
+                if (lexer.token() == Token.COMMA) {
+                    lexer.nextToken();
+                    continue;
                }

-                lexer.nextToken();
+                break;
            }

            // while
@@ -56,8 +56,10 @@ 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.SQLPrimaryKey;
 import com.alibaba.druid.sql.ast.statement.SQLSelect;
 import com.alibaba.druid.sql.ast.statement.SQLSelectOrderByItem;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OraclePrimaryKey;

 public class SQLExprParser extends SQLParser {

@@ -214,6 +216,7 @@ public class SQLExprParser extends SQLParser {
            case LIMIT:
            case SCHEMA:
            case AT:
+            case COLUMN:
                sqlExpr = new SQLIdentifierExpr(lexer.stringVal());
                lexer.nextToken();
                break;
@@ -1131,4 +1134,8 @@ public class SQLExprParser extends SQLParser {

        return column;
    }
+    
+    public SQLPrimaryKey parsePrimaryKey() {
+        throw new ParserException("TODO");
+    }
 }
@@ -286,7 +286,7 @@ public class SQLStatementParser extends SQLParser {
        if (token == Token.TABLE || identifierEquals("GLOBAL")) {
            SQLCreateTableParser createTableParser = getSQLCreateTableParser();
            return createTableParser.parseCrateTable(false);
-        } else if (token == Token.INDEX) {
+        } else if (token == Token.INDEX || token == Token.UNIQUE) {
            return parseCreateIndex(false);
        }

@@ -66,6 +66,45 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
    public final static String                         ATTR_COLUMN    = "_column_";

    private Mode                                       mode;
+    
+    public TableStat getTableStat(String ident) {
+        return getTableStat(ident, null);
+    }
+    
+    public Column addColumn(String tableName, String columnName) {
+        tableName = handleName(tableName);
+        columnName = handleName(columnName);
+        
+        Column column = new Column(tableName, columnName);
+        columns.add(column);
+        return column;
+    }
+
+    public TableStat getTableStat(String tableName, String alias) {
+        if (variants.containsKey(tableName)){
+            return null;
+        }
+        
+        tableName = handleName(tableName);
+        TableStat stat = tableStats.get(tableName);
+        if (stat == null) {
+            stat = new TableStat();
+            tableStats.put(new TableStat.Name(tableName), stat);
+            if (alias != null) {
+                aliasMap.put(alias, tableName);    
+            }
+        }
+        return stat;
+    }
+
+    private String handleName(String ident) {
+        ident = ident.replaceAll("\"", "");
+        ident = ident.replaceAll(" ", "");
+        
+        ident = aliasWrap(ident);
+        
+        return ident;
+    }

    public Map<String, SQLObject> getVariants() {
        return variants;
@@ -91,6 +130,10 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
        this.currentTable = table;
    }

+    public void setCurrentTable(SQLObject x) {
+        x.putAttribute("_old_local_", this.currentTable);
+    }
+
    public void restoreCurrentTable(SQLObject x) {
        String table = (String) x.getAttribute("_old_local_");
        this.currentTable = table;
@@ -330,11 +373,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
            setCurrentTable(ident);
            x.putAttribute("_old_local_", originalTable);

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-            }
+            TableStat stat = getTableStat(ident);
            stat.incrementInsertCount();

            Map<String, String> aliasMap = getAliasMap();
@@ -359,11 +398,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
            setCurrentTable(ident);
            x.putAttribute("_old_local_", originalTable);

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-            }
+            TableStat stat = getTableStat(ident);
            stat.incrementDropCount();

            Map<String, String> aliasMap = getAliasMap();
@@ -388,11 +423,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
            setCurrentTable(ident);
            x.putAttribute("_old_local_", originalTable);

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-            }
+            TableStat stat = getTableStat(ident);
            stat.incrementInsertCount();

            Map<String, String> aliasMap = getAliasMap();
@@ -437,7 +468,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
            if (tableSource.getExpr() instanceof SQLName) {
                String ident = tableSource.getExpr().toString();

-                setCurrentTable(ident);
+                setCurrentTable(x, ident);
                x.putAttribute(ATTR_TABLE, ident);
                if (x.getParent() instanceof SQLSelect) {
                    x.getParent().putAttribute(ATTR_TABLE, ident);
@@ -448,6 +479,10 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {

        if (x.getFrom() != null) {
            x.getFrom().accept(this); // 提前执行，获得aliasMap
+            String table = (String) x.getFrom().getAttribute(ATTR_TABLE);
+            if (table != null) {
+                x.putAttribute(ATTR_TABLE, table);
+            }
        }

        if (x.getWhere() != null) {
@@ -480,8 +515,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
            owner = aliasWrap(owner);

            if (owner != null) {
-                Column column = new Column(owner, x.getName());
-                columns.add(column);
+                Column column = addColumn(owner, x.getName());
                x.putAttribute(ATTR_COLUMN, column);
            }
        }
@@ -546,8 +580,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
        }

        if (currentTable != null) {
-            Column column = new Column(currentTable, ident);
-            columns.add(column);
+            Column column = addColumn(currentTable, ident);
            x.putAttribute(ATTR_COLUMN, column);
        } else {
            Column column = handleUnkownColumn(ident);
@@ -559,9 +592,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
    }

    protected Column handleUnkownColumn(String columnName) {
-        Column column = new Column("UNKNOWN", columnName);
-        columns.add(column);
-        return column;
+        return addColumn("UNKNOWN", columnName);
    }

    public boolean visit(SQLAllColumnExpr x) {
@@ -572,7 +603,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
        }

        if (currentTable != null) {
-            columns.add(new Column(currentTable, "*"));
+            addColumn(currentTable, "*");
        }
        return false;
    }
@@ -627,12 +658,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {

            Map<String, String> aliasMap = getAliasMap();

-            TableStat stat = tableStats.get(ident);
-            if (stat == null) {
-                stat = new TableStat();
-                tableStats.put(new TableStat.Name(ident), stat);
-                x.putAttribute(ATTR_TABLE, ident);
-            }
+            TableStat stat = getTableStat(ident);

            Mode mode = getMode();
            switch (mode) {
@@ -673,7 +699,13 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
        return true;
    }

+    public void endVisit(SQLSelect x) {
+        restoreCurrentTable(x);
+    }
+
    public boolean visit(SQLSelect x) {
+        setCurrentTable(x);
+
        if (x.getOrderBy() != null) {
            x.getOrderBy().setParent(x);
        }
@@ -708,11 +740,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
        String ident = x.getTableName().toString();
        setCurrentTable(ident);

-        TableStat stat = tableStats.get(ident);
-        if (stat == null) {
-            stat = new TableStat();
-            tableStats.put(new TableStat.Name(ident), stat);
-        }
+        TableStat stat = getTableStat(ident);
        stat.incrementUpdateCount();

        Map<String, String> aliasMap = getAliasMap();
@@ -732,11 +760,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
        String ident = x.getTableName().toString();
        setCurrentTable(ident);

-        TableStat stat = tableStats.get(ident);
-        if (stat == null) {
-            stat = new TableStat();
-            tableStats.put(new TableStat.Name(ident), stat);
-        }
+        TableStat stat = getTableStat(ident);
        stat.incrementDeleteCount();

        accept(x.getWhere());
@@ -778,11 +802,14 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
        }

        String tableName = x.getName().toString();
-        TableStat stat = new TableStat();
+        
+        TableStat stat = getTableStat(tableName);
        stat.incrementCreateCount();
-        tableStats.put(new TableStat.Name(tableName), stat);
+        setCurrentTable(x, tableName);

        accept(x.getTableElementList());
+        
+        restoreCurrentTable(x);

        return false;
    }
@@ -801,7 +828,7 @@ public class SchemaStatVisitor extends SQLASTVisitorAdapter {
        }

        String columnName = x.getName().toString();
-        columns.add(new Column(tableName, columnName));
+        addColumn(tableName, columnName);

        return false;
    }