bug fixed for oracle sql parser

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

@@ -0,0 +1,39 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.clause;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.dialect.oracle.ast.OracleSQLObjectImpl;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+
+public class StorageItem extends OracleSQLObjectImpl {
+
+    private static final long serialVersionUID = 1L;
+    private SQLName           name;
+    private SQLExpr           value;
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+    public SQLExpr getValue() {
+        return value;
+    }
+
+    public void setValue(SQLExpr value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+            acceptChild(visitor, value);
+        }
+        visitor.endVisit(this);
+    }
+
+}

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

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

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

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

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

@@ -1,14 +1,56 @@
 package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import com.alibaba.druid.sql.ast.SQLName;
 import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
+import com.alibaba.druid.sql.ast.statement.SQLSelect;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.StorageItem;
+import com.alibaba.druid.sql.dialect.oracle.visitor.OracleASTVisitor;
+import com.alibaba.druid.sql.visitor.SQLASTVisitor;
 
-public class OracleCreateTableStatement extends SQLCreateTableStatement {
+public class OracleCreateTableStatement extends SQLCreateTableStatement implements OracleStatement {
 
     private static final long serialVersionUID = 1L;
 
     private SQLName           tablespace;
 
+    private SQLSelect         select;
+
+    private boolean           inMemoryMetadata;
+
+    private boolean           cursorSpecificSegment;
+
+    // NOPARALLEL
+    private Boolean           parallel;
+
+    private List<StorageItem> storage          = new ArrayList<StorageItem>();
+
+    public Boolean getParallel() {
+        return parallel;
+    }
+
+    public void setParallel(Boolean parallel) {
+        this.parallel = parallel;
+    }
+
+    public boolean isCursorSpecificSegment() {
+        return cursorSpecificSegment;
+    }
+
+    public void setCursorSpecificSegment(boolean cursorSpecificSegment) {
+        this.cursorSpecificSegment = cursorSpecificSegment;
+    }
+
+    public boolean isInMemoryMetadata() {
+        return inMemoryMetadata;
+    }
+
+    public void setInMemoryMetadata(boolean inMemoryMetadata) {
+        this.inMemoryMetadata = inMemoryMetadata;
+    }
+
     public SQLName getTablespace() {
         return tablespace;
     }
@@ -17,4 +59,35 @@ public class OracleCreateTableStatement extends SQLCreateTableStatement {
         this.tablespace = tablespace;
     }
 
+    public SQLSelect getSelect() {
+        return select;
+    }
+
+    public void setSelect(SQLSelect select) {
+        this.select = select;
+    }
+
+    protected void accept0(SQLASTVisitor visitor) {
+        accept0((OracleASTVisitor) visitor);
+    }
+
+    public List<StorageItem> getStorage() {
+        return storage;
+    }
+
+    public void setStorage(List<StorageItem> storage) {
+        this.storage = storage;
+    }
+
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            this.acceptChild(visitor, name);
+            this.acceptChild(visitor, tableElementList);
+            this.acceptChild(visitor, tablespace);
+            this.acceptChild(visitor, select);
+            this.acceptChild(visitor, storage);
+        }
+        visitor.endVisit(this);
+    }
+
 }

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

@@ -0,0 +1,55 @@
+package com.alibaba.druid.sql.dialect.oracle.ast.stmt;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.SQLName;
+import com.alibaba.druid.sql.ast.statement.SQLPrimaryKey;
+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 {
+
+    private static final long serialVersionUID = 1L;
+
+    private SQLName           name;
+    private List<SQLExpr>     columns          = new ArrayList<SQLExpr>();
+
+    private SQLExpr           usingIndex;
+
+    @Override
+    public void accept0(OracleASTVisitor visitor) {
+        if (visitor.visit(this)) {
+            acceptChild(visitor, name);
+            acceptChild(visitor, columns);
+            acceptChild(visitor, usingIndex);
+        }
+        visitor.endVisit(this);
+    }
+
+    public SQLName getName() {
+        return name;
+    }
+
+    public void setName(SQLName name) {
+        this.name = name;
+    }
+
+    public List<SQLExpr> getColumns() {
+        return columns;
+    }
+
+    public void setColumns(List<SQLExpr> columns) {
+        this.columns = columns;
+    }
+
+    public SQLExpr getUsingIndex() {
+        return usingIndex;
+    }
+
+    public void setUsingIndex(SQLExpr usingIndex) {
+        this.usingIndex = usingIndex;
+    }
+
+}

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

@@ -1,8 +1,11 @@
 package com.alibaba.druid.sql.dialect.oracle.parser;
 
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.StorageItem;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelect;
 import com.alibaba.druid.sql.parser.Lexer;
 import com.alibaba.druid.sql.parser.SQLCreateTableParser;
+import com.alibaba.druid.sql.parser.Token;
 
 public class OracleCreateTableParser extends SQLCreateTableParser {
 
@@ -20,15 +23,53 @@ public class OracleCreateTableParser extends SQLCreateTableParser {
     protected OracleCreateTableStatement newCreateStatement() {
         return new OracleCreateTableStatement();
     }
-    
+
     public OracleCreateTableStatement parseCrateTable(boolean acceptCreate) {
         OracleCreateTableStatement stmt = (OracleCreateTableStatement) super.parseCrateTable(acceptCreate);
-        
-        if (identifierEquals("TABLESPACE")) {
-            lexer.nextToken();
-            stmt.setTablespace(this.exprParser.name());
+
+        for (;;) {
+            if (identifierEquals("TABLESPACE")) {
+                lexer.nextToken();
+                stmt.setTablespace(this.exprParser.name());
+            } else if (identifierEquals("IN_MEMORY_METADATA")) {
+                lexer.nextToken();
+                stmt.setInMemoryMetadata(true);
+                continue;
+            } else if (identifierEquals("CURSOR_SPECIFIC_SEGMENT")) {
+                lexer.nextToken();
+                stmt.setCursorSpecificSegment(true);
+                continue;
+            } else if (identifierEquals("NOPARALLEL")) {
+                lexer.nextToken();
+                stmt.setParallel(false);
+                continue;
+            } else if (identifierEquals("STORAGE")) {
+                lexer.nextToken();
+                accept(Token.LPAREN);
+
+                for (;;) {
+                    if (lexer.token() == Token.IDENTIFIER) {
+                        StorageItem item = new StorageItem();
+                        item.setName(this.exprParser.name());
+                        item.setValue(this.exprParser.expr());
+                        stmt.getStorage().add(item);
+                    } else {
+                        break;
+                    }
+                }
+                accept(Token.RPAREN);
+                continue;
+            }
+            break;
         }
-        
+
+        if (lexer.token() == Token.AS) {
+            lexer.nextToken();
+
+            OracleSelect select = new OracleSelectParser(lexer).select();
+            stmt.setSelect(select);
+        }
+
         return stmt;
     }
 }

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

@@ -39,8 +39,11 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.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.OracleAlterTableRenameTo;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.NestedTablePartitionSpec;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.TableSpaceItem;
@@ -62,6 +65,7 @@ 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;
@@ -297,7 +301,7 @@ public class OracleStatementParser extends SQLStatementParser {
 
                 accept(Token.THEN);
                 this.parseStatementList(elseIf.getStatements());
-                
+
                 stmt.getElseIfList().add(elseIf);
             } else {
                 OracleIfStatement.Else elseItem = new OracleIfStatement.Else();
@@ -306,7 +310,7 @@ public class OracleStatementParser extends SQLStatementParser {
                 break;
             }
         }
-        
+
         accept(Token.END);
         accept(Token.IF);
 
@@ -456,24 +460,26 @@ public class OracleStatementParser extends SQLStatementParser {
             if (identifierEquals("ADD")) {
                 lexer.nextToken();
 
-                SQLColumnDefinition columnDef;
                 if (lexer.token() == Token.LPAREN) {
                     lexer.nextToken();
-                    columnDef = this.exprParser.parseColumn();
+                    SQLColumnDefinition columnDef = this.exprParser.parseColumn();
                     accept(Token.RPAREN);
+
+                    OracleAlterTableAddColumn item = new OracleAlterTableAddColumn();
+                    item.setColumn(columnDef);
+
+                    stmt.getItems().add(item);
+                } else if (lexer.token() == Token.CONSTRAINT) {
+                    stmt.getItems().add(parseConstaint());
                 } else {
-                    columnDef = this.exprParser.parseColumn();
+                    throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
                 }
 
-                OracleAlterTableAddColumn item = new OracleAlterTableAddColumn();
-                item.setColumn(columnDef);
-
-                stmt.getItems().add(item);
                 continue;
             } else if (identifierEquals("MOVE")) {
                 throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
             } else if (identifierEquals("RENAME")) {
-                throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+                stmt.getItems().add(parseAlterTableRename());
             } else if (identifierEquals("MODIFY")) {
                 lexer.nextToken();
 
@@ -522,6 +528,51 @@ public class OracleStatementParser extends SQLStatementParser {
         return stmt;
     }
 
+    private OracleAlterTableItem parseAlterTableRename() {
+        acceptIdentifier("RENAME");
+        
+        if (lexer.token() == Token.TO) {
+            lexer.nextToken();
+            OracleAlterTableRenameTo item = new OracleAlterTableRenameTo();
+            item.setTo(this.exprParser.name());
+            return item;
+        }
+        throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+    }
+
+    private OracleAlterTableAddConstaint parseConstaint() {
+        accept(Token.CONSTRAINT);
+
+        OracleAlterTableAddConstaint item = new OracleAlterTableAddConstaint();
+
+        SQLName name = this.exprParser.name();
+
+        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;
+        }
+
+        throw new ParserException("TODO : " + lexer.token() + " " + lexer.stringVal());
+    }
+
     private void parseAlterTableDrop(OracleAlterTableStatement stmt) {
         lexer.nextToken();
         if (identifierEquals("PARTITION")) {
@@ -645,7 +696,7 @@ public class OracleStatementParser extends SQLStatementParser {
             for (;;) {
                 SQLColumnDefinition parameter = this.exprParser.parseColumn();
                 block.getParameters().add(parameter);
-                
+
                 if (lexer.token() == Token.COLONEQ) {
                     lexer.nextToken();
                     parameter.setDefaultExpr(this.exprParser.expr());

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

@@ -21,6 +21,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SampleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SearchClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.StorageItem;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause.Entry;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAggregateExpr;
@@ -44,14 +45,17 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.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.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.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExplainStatement;
@@ -72,6 +76,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.InsertIntoClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleOrderByItem;
 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.OracleSelect;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectForUpdate;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectHierachicalQueryClause;
@@ -1093,5 +1098,55 @@ public class OracleASTVIsitorAdapter extends SQLASTVisitorAdapter implements Ora
     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
+    public boolean visit(StorageItem x) {
+        return true;
+    }
+
+    @Override
+    public void endVisit(StorageItem x) {
+        
+    }
 
 }

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

@@ -28,6 +28,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SampleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SearchClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.StorageItem;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAggregateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAnalytic;
@@ -50,14 +51,17 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.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.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.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExplainStatement;
@@ -76,6 +80,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.InsertIntoClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleOrderByItem;
 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.OracleSelect;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectForUpdate;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectHierachicalQueryClause;
@@ -424,60 +429,80 @@ public interface OracleASTVisitor extends SQLASTVisitor {
     boolean visit(OracleAlterTableStatement x);
 
     void endVisit(OracleAlterTableStatement x);
-    
+
     boolean visit(OracleAlterTableSplitPartition.TableSpaceItem x);
-    
+
     void endVisit(OracleAlterTableSplitPartition.TableSpaceItem x);
-    
+
     boolean visit(OracleAlterTableSplitPartition.UpdateIndexesClause x);
-    
+
     void endVisit(OracleAlterTableSplitPartition.UpdateIndexesClause x);
-    
+
     boolean visit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x);
-    
+
     void endVisit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x);
-    
+
     boolean visit(OracleAlterTableSplitPartition x);
-    
+
     void endVisit(OracleAlterTableSplitPartition x);
-    
+
     boolean visit(OracleAlterTableModify x);
-    
+
     void endVisit(OracleAlterTableModify x);
-    
+
     boolean visit(OracleAlterTableAddColumn x);
-    
+
     void endVisit(OracleAlterTableAddColumn x);
-    
+
     boolean visit(OracleCreateIndexStatement x);
-    
+
     void endVisit(OracleCreateIndexStatement x);
-    
+
     boolean visit(OracleForStatement x);
-    
+
     void endVisit(OracleForStatement x);
-    
+
     boolean visit(Else x);
-    
+
     void endVisit(Else x);
-    
+
     boolean visit(ElseIf x);
-    
+
     void endVisit(ElseIf x);
-    
+
     boolean visit(OracleIfStatement x);
-    
+
     void endVisit(OracleIfStatement x);
-    
+
     boolean visit(OracleRangeExpr x);
-    
+
     void endVisit(OracleRangeExpr x);
-    
+
     boolean visit(OracleAlterIndexStatement x);
-    
+
     void endVisit(OracleAlterIndexStatement x);
-    
+
+    boolean visit(OracleAlterTableAddConstaint x);
+
+    void endVisit(OracleAlterTableAddConstaint x);
+
+    boolean visit(OracleAlterTableRenameTo x);
+
+    void endVisit(OracleAlterTableRenameTo x);
+
+    boolean visit(OraclePrimaryKey x);
+
+    void endVisit(OraclePrimaryKey x);
+
+    boolean visit(OracleCreateTableStatement x);
+
+    void endVisit(OracleCreateTableStatement x);
+
     boolean visit(OracleAlterIndexStatement.Rebuild x);
-    
+
     void endVisit(OracleAlterIndexStatement.Rebuild x);
+
+    boolean visit(StorageItem x);
+
+    void endVisit(StorageItem x);
 }

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

@@ -29,6 +29,7 @@ import com.alibaba.druid.sql.ast.expr.SQLLiteralExpr;
 import com.alibaba.druid.sql.ast.expr.SQLMethodInvokeExpr;
 import com.alibaba.druid.sql.ast.expr.SQLObjectCreateExpr;
 import com.alibaba.druid.sql.ast.statement.SQLColumnDefinition;
+import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
 import com.alibaba.druid.sql.ast.statement.SQLInsertStatement;
 import com.alibaba.druid.sql.ast.statement.SQLJoinTableSource.JoinType;
 import com.alibaba.druid.sql.ast.statement.SQLSelect;
@@ -56,6 +57,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SampleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SearchClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.StorageItem;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAggregateExpr;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAnalytic;
@@ -79,9 +81,11 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement.R
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.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.OracleAlterTableRenameTo;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.NestedTablePartitionSpec;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableSplitPartition.TableSpaceItem;
@@ -91,6 +95,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableTruncatePar
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExplainStatement;
@@ -111,6 +116,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.InsertIntoClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleOrderByItem;
 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.OracleSelect;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectForUpdate;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectHierachicalQueryClause;
@@ -2307,4 +2313,110 @@ public class OracleOutputVisitor extends SQLASTOutputVisitor implements OracleAS
         }
         x.getDefaultExpr().accept(this);
     }
+
+    @Override
+    public boolean visit(OracleAlterTableAddConstaint x) {
+        print("ADD ");
+        x.getConstraint().accept(this);
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableAddConstaint x) {
+
+    }
+
+    @Override
+    public boolean visit(OraclePrimaryKey x) {
+        if (x.getName() != null) {
+            print("CONSTRAINT ");
+            x.getName().accept(this);
+            print(" ");
+        }
+        print("PRIMARY KEY (");
+        printAndAccept(x.getColumns(), ", ");
+        print(")");
+        if (x.getUsingIndex() != null) {
+            print(" USING INDEX ");
+            x.getUsingIndex().accept(this);
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(OraclePrimaryKey x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleCreateTableStatement x) {
+        this.visit((SQLCreateTableStatement) x);
+
+        incrementIndent();
+        if (x.getTablespace() != null) {
+            print(" TABLESPACE ");
+            x.getTablespace().accept(this);
+        }
+        
+        if (x.isInMemoryMetadata()) {
+            print(" IN_MEMORY_METADATA");
+        }
+        
+        if (x.isCursorSpecificSegment()) {
+            print(" CURSOR_SPECIFIC_SEGMENT");
+        }
+        
+        if (x.getParallel() == Boolean.TRUE) {
+            
+        } else if (x.getParallel() == Boolean.FALSE) {
+            print(" NOPARALLEL");
+        }
+        
+        if (x.getStorage().size() > 0) {
+            print(" STORAGE (");
+            printAndAccept(x.getStorage(), ", ");
+            print(")");
+        }
+
+        if (x.getSelect() != null) {
+            println();
+            print("AS");
+            println();
+            x.getSelect().accept(this);
+        }
+        decrementIndent();
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleCreateTableStatement x) {
+
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableRenameTo x) {
+        print("RENAME TO ");
+        x.getTo().accept(this);
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableRenameTo x) {
+        
+    }
+
+    @Override
+    public boolean visit(StorageItem x) {
+        x.getName().accept(this);
+        if (x.getValue() != null) {
+            print(" ");
+            x.getValue().accept(this);
+        }
+        return false;
+    }
+
+    @Override
+    public void endVisit(StorageItem x) {
+        
+    }
 }

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

@@ -12,6 +12,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.SQLCreateTableStatement;
 import com.alibaba.druid.sql.ast.statement.SQLDeleteStatement;
 import com.alibaba.druid.sql.ast.statement.SQLExprTableSource;
 import com.alibaba.druid.sql.ast.statement.SQLInsertStatement;
@@ -38,6 +39,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.clause.OracleReturningClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.PartitionExtensionClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SampleClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SearchClause;
+import com.alibaba.druid.sql.dialect.oracle.ast.clause.StorageItem;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.clause.SubqueryFactoringClause.Entry;
 import com.alibaba.druid.sql.dialect.oracle.ast.expr.OracleAggregateExpr;
@@ -61,14 +63,17 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterIndexStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterProcedureStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterSessionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleAlterTableAddColumn;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.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.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.OracleBlockStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleConstraintState;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateIndexStatement;
+import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleCreateTableStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleDeleteStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExceptionStatement;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleExplainStatement;
@@ -89,6 +94,7 @@ import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleMultiInsertStatement.InsertIntoClause;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleOrderByItem;
 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.OracleSelect;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectForUpdate;
 import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleSelectHierachicalQueryClause;
@@ -1434,4 +1440,55 @@ public class OracleSchemaStatVisitor extends SchemaStatVisitor implements Oracle
     public void endVisit(OracleRangeExpr x) {
         
     }
+    
+    @Override
+    public boolean visit(OracleAlterTableAddConstaint x) {
+        return false;
+    }
+    
+    @Override
+    public void endVisit(OracleAlterTableAddConstaint x) {
+        
+    }
+
+    @Override
+    public boolean visit(OraclePrimaryKey x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OraclePrimaryKey x) {
+        
+    }
+    
+    @Override
+    public boolean visit(OracleCreateTableStatement x) {
+        this.visit((SQLCreateTableStatement) x);
+        return false;
+    }
+    
+    @Override
+    public void endVisit(OracleCreateTableStatement x) {
+        this.endVisit((SQLCreateTableStatement) x);
+    }
+
+    @Override
+    public boolean visit(OracleAlterTableRenameTo x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(OracleAlterTableRenameTo x) {
+        
+    }
+
+    @Override
+    public boolean visit(StorageItem x) {
+        return false;
+    }
+
+    @Override
+    public void endVisit(StorageItem x) {
+        
+    }
 }

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

@@ -39,14 +39,14 @@ public class SQLCreateTableParser extends SQLDDLParser {
 
         SQLCreateTableStatement createTable = newCreateStatement();
 
-        if (lexer.token() == Token.IDENTIFIER && lexer.stringVal().equalsIgnoreCase("GLOBAL")) {
+        if (identifierEquals("GLOBAL")) {
             lexer.nextToken();
 
-            if (lexer.token() == Token.IDENTIFIER && lexer.stringVal().equalsIgnoreCase("TEMPORAY")) {
+            if (identifierEquals("TEMPORARY")) {
                 lexer.nextToken();
                 createTable.setType(SQLCreateTableStatement.Type.GLOBAL_TEMPORARY);
             } else {
-                throw new ParserException("syntax error");
+                throw new ParserException("syntax error " + lexer.token() + " " + lexer.stringVal());
             }
         } else if (lexer.token() == Token.IDENTIFIER && lexer.stringVal().equalsIgnoreCase("LOCAL")) {
             lexer.nextToken();
@@ -65,7 +65,7 @@ public class SQLCreateTableParser extends SQLDDLParser {
         if (lexer.token() == Token.LPAREN) {
             lexer.nextToken();
 
-            while (lexer.token() == Token.IDENTIFIER) {
+            while (lexer.token() == Token.IDENTIFIER || lexer.token() == Token.LITERAL_ALIAS) {
                 SQLColumnDefinition column = this.exprParser.parseColumn();
                 createTable.getTableElementList().add(column);
 

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

@@ -284,7 +284,7 @@ public class SQLStatementParser extends SQLParser {
 
         Token token = lexer.token();
 
-        if (token == Token.TABLE) {
+        if (token == Token.TABLE || identifierEquals("GLOBAL")) {
             SQLCreateTableParser createTableParser = getSQLCreateTableParser();
             return createTableParser.parseCrateTable(false);
         } else if (token == Token.INDEX) {

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

@@ -553,7 +553,7 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter {
 
     public boolean visit(SQLColumnDefinition x) {
         x.getName().accept(this);
-        
+
         if (x.getDataType() != null) {
             print(' ');
             x.getDataType().accept(this);
@@ -669,15 +669,20 @@ public class SQLASTOutputVisitor extends SQLASTVisitorAdapter {
         }
 
         x.getName().accept(this);
-        print(" (");
 
-        for (int i = 0, size = x.getTableElementList().size(); i < size; ++i) {
-            if (i != 0) {
-                print(", ");
+        int size = x.getTableElementList().size();
+
+        if (size > 0) {
+            print(" (");
+
+            for (int i = 0; i < size; ++i) {
+                if (i != 0) {
+                    print(", ");
+                }
+                x.getTableElementList().get(i).accept(this);
             }
-            x.getTableElementList().get(i).accept(this);
+            print(")");
         }
-        print(")");
 
         return false;
     }