Add sqlserver mysql alter table visitor

sharding-jdbc-ddl-parser/src/main/antlr4/io/shardingsphere/parser/antlr/mysql/MySQLAlterTable.g4

@@ -28,7 +28,7 @@ alterSpecification:
     | FORCE
     | lockOption
     | modifyColumn
-    | (ORDER BY columnName (COMMA columnName)* )+ 
+    | (ORDER BY columnName (COMMA columnName)*)+ 
     | renameIndex
     | renameTable
     | (WITHOUT|WITH) VALIDATION

sharding-jdbc-ddl-parser/src/main/java/io/shardingsphere/core/parsing/antler/VisitorManager.java

@@ -4,10 +4,13 @@ import java.util.HashMap;
 import java.util.Map;
 
 import io.shardingsphere.core.constant.DatabaseType;
-import io.shardingsphere.core.parsing.antler.visitor.AlterTableVisitor;
 import io.shardingsphere.core.parsing.antler.visitor.CreateTableVisitor;
 import io.shardingsphere.core.parsing.antler.visitor.OnlyTableVisitor;
 import io.shardingsphere.core.parsing.antler.visitor.SQLVisitor;
+import io.shardingsphere.core.parsing.antler.visitor.mysql.MySQLAlterTableVisitor;
+import io.shardingsphere.core.parsing.antler.visitor.oracle.OracleAlterTableVisitor;
+import io.shardingsphere.core.parsing.antler.visitor.postgre.PostgreAlterTableVisitor;
+import io.shardingsphere.core.parsing.antler.visitor.sqlserver.SQLServerAlterTableVisitor;
 
 public class VisitorManager {
     private Map<String, SQLVisitor> visitors = new HashMap<String, SQLVisitor>();
@@ -15,7 +18,10 @@ public class VisitorManager {
 
     private VisitorManager() {
         visitors.put("CreateTable", new CreateTableVisitor());
-        visitors.put("AlterTable", new AlterTableVisitor());
+        visitors.put(DatabaseType.MySQL+"AlterTable", new MySQLAlterTableVisitor());
+        visitors.put(DatabaseType.PostgreSQL+"AlterTable", new PostgreAlterTableVisitor());
+        visitors.put(DatabaseType.Oracle+"AlterTable", new OracleAlterTableVisitor());
+        visitors.put(DatabaseType.SQLServer+"AlterTable", new SQLServerAlterTableVisitor());
         visitors.put("DropTable", new OnlyTableVisitor());
         visitors.put("TruncateTable", new OnlyTableVisitor());
     }
@@ -32,7 +38,7 @@ public class VisitorManager {
      * @return
      */
     public SQLVisitor getVisitor(final DatabaseType dbType, final String commandName) {
-        String key = dbType.name() + "-" + commandName;
+        String key = dbType.name() + commandName;
         SQLVisitor visitor = visitors.get(key);
         if (visitor != null) {
             return visitor;

sharding-jdbc-ddl-parser/src/main/java/io/shardingsphere/core/parsing/antler/visitor/AlterTableVisitor.java

 package io.shardingsphere.core.parsing.antler.visitor;
 
 import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ParseTree;
 
+import io.shardingsphere.core.parsing.antler.sql.ddl.AlterTableStatement;
+import io.shardingsphere.core.parsing.antler.utils.VisitorUtils;
 import io.shardingsphere.core.parsing.parser.sql.SQLStatement;
 
-public class AlterTableVisitor extends AbstractSQLVisitor {
+public abstract class AlterTableVisitor extends AbstractSQLVisitor {
 
     @Override
     protected SQLStatement newStatement() {
-        // TODO Auto-generated method stub
-        return null;
+        return new AlterTableStatement();
     }
 
     @Override
-    protected void visit(final ParserRuleContext rootNode, final SQLStatement statement) {
-        // TODO Auto-generated method stub
-        
+    protected final void visit(final ParserRuleContext rootNode, final SQLStatement statement) {
+        AlterTableStatement alterStatement = (AlterTableStatement) statement;
+        VisitorUtils.parseTable(statement, rootNode);
+        if (VisitorUtils.parseRenameTable(alterStatement, rootNode)) {
+            return;
+        }
+
+        VisitorUtils.parseAddColumn(alterStatement, rootNode);
+        VisitorUtils.visitDropColumn(alterStatement, rootNode);
+
+        visitPrivateTree(alterStatement, rootNode);
     }
 
-   
+    /**
+     * Visit private ast nodes.
+     * 
+     * @param statement
+     *            statement parse result
+     * @param rootNode
+     *            Root node of syntax tree
+     */
+    protected abstract void visitPrivateTree(final AlterTableStatement statement, final ParseTree rootNode);
 
 }

sharding-jdbc-ddl-parser/src/main/java/io/shardingsphere/core/parsing/antler/visitor/mysql/MySQLAlterTableVisitor.java

+package io.shardingsphere.core.parsing.antler.visitor.mysql;
+
+import java.util.List;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ParseTree;
+
+import io.shardingsphere.core.parsing.antler.sql.ddl.AlterTableStatement;
+import io.shardingsphere.core.parsing.antler.sql.ddl.ColumnDefinition;
+import io.shardingsphere.core.parsing.antler.utils.TreeUtils;
+import io.shardingsphere.core.parsing.antler.utils.VisitorUtils;
+import io.shardingsphere.core.parsing.antler.visitor.AlterTableVisitor;
+import io.shardingsphere.core.parsing.parser.token.IndexToken;
+
+public class MySQLAlterTableVisitor extends AlterTableVisitor {
+    @Override
+    protected void visitPrivateTree(AlterTableStatement statement, ParseTree rootNode) {
+        visitAddIndex(statement, rootNode);
+        visitDropIndex(statement, rootNode);
+        visitAddPrimaryKey(statement, rootNode);
+        
+        VisitorUtils.parseModifyColumn(statement, rootNode);
+        VisitorUtils.parseRenameIndex(statement, rootNode);
+        VisitorUtils.parseAddPrimaryKey(statement, rootNode);
+        VisitorUtils.parseDropPrimaryKey(statement, rootNode);
+    }
+    
+    
+    /**
+     * Visit add index node.
+     * 
+     * @param statement
+     *            statement parse result
+     * @param ancestorNode
+     *            ancestor of index node
+     * @return indexName node
+     */
+    protected void visitAddIndex(final AlterTableStatement statement, final ParseTree rootNode) {
+        ParserRuleContext indexDefOptionNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(rootNode,
+                "indexDefOption");
+        if (null != indexDefOptionNode) {
+            ParserRuleContext indexNameNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(indexDefOptionNode,
+                    "indexName");
+            if (null != indexNameNode) {
+                statement.getSqlTokens().add(new IndexToken(indexNameNode.getStart().getStartIndex(),
+                        indexNameNode.getText(), statement.getTables().getSingleTableName()));
+            }
+        }
+    }
+    
+    
+    /**
+     * Visit drop index node.
+     * 
+     * @param statement
+     *            statement parse result
+     * @param ancestorNode
+     *            ancestor of index node
+     * @return indexName node
+     */
+    protected void visitDropIndex(final AlterTableStatement statement, final ParseTree ancestorNode) {
+        ParserRuleContext dropIndexDefNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(ancestorNode,
+                "dropIndexDef");
+        if (null == dropIndexDefNode) {
+            return;
+        }
+
+        ParserRuleContext indexNameNode = (ParserRuleContext) dropIndexDefNode
+                .getChild(dropIndexDefNode.getChildCount() - 1);
+        if (null != indexNameNode) {
+            statement.getSqlTokens().add(new IndexToken(indexNameNode.getStart().getStartIndex(),
+                    indexNameNode.getText(), statement.getTables().getSingleTableName()));
+        }
+    }
+
+    /**
+     * Visit add primary key.
+     * 
+     * @param statement
+     *            statement parse result
+     * @param ancestorNode
+     *            ancestor of index node
+     * @return indexName node
+     */
+    protected void visitAddPrimaryKey(final AlterTableStatement statement, final ParseTree ancestorNode) {
+        ParserRuleContext constraintDefinitionNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(ancestorNode,
+                "constraintDefinition");
+        if (null == constraintDefinitionNode) {
+            return;
+        }
+
+        ParserRuleContext primaryKeyOptionNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(ancestorNode,
+                "primaryKeyOption");
+        if (null == primaryKeyOptionNode) {
+            return;
+        }
+
+        List<ParseTree> keyPartNodes = TreeUtils.getAllDescendantByRuleName(ancestorNode, "keyPart");
+        if (null == keyPartNodes) {
+            return;
+        }
+
+        for (final ParseTree each : keyPartNodes) {
+            String columnName = each.getChild(0).getText();
+            ColumnDefinition updateColumn = statement.getUpdateColumns().get(columnName);
+            if (null == updateColumn) {
+                updateColumn = new ColumnDefinition(columnName, null, null, true);
+                statement.getUpdateColumns().put(columnName, updateColumn);
+            } else {
+                updateColumn.setPrimaryKey(true);
+            }
+        }
+    }
+
+}

sharding-jdbc-ddl-parser/src/main/java/io/shardingsphere/core/parsing/antler/visitor/sqlserver/SQLServerAlterTableVisitor.java

+package io.shardingsphere.core.parsing.antler.visitor.sqlserver;
+
+import java.util.List;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ParseTree;
+
+import io.shardingsphere.core.parsing.antler.sql.ddl.AlterTableStatement;
+import io.shardingsphere.core.parsing.antler.sql.ddl.ColumnDefinition;
+import io.shardingsphere.core.parsing.antler.utils.TreeUtils;
+import io.shardingsphere.core.parsing.antler.visitor.AlterTableVisitor;
+import io.shardingsphere.core.parsing.parser.token.IndexToken;
+
+public class SQLServerAlterTableVisitor extends AlterTableVisitor {
+    protected void visitPrivateTree(final AlterTableStatement statement, final ParseTree rootNode) {
+        visitAddIndex(statement, rootNode);
+        visitDropIndex(statement, rootNode);
+        visitAddPrimaryKey(statement, rootNode);//drop primary key need use drop constraint
+    }
+
+    /**
+     * Visit add index node.
+     * 
+     * @param statement
+     *            statement parse result
+     * @param ancestorNode
+     *            ancestor of index node
+     * @return indexName node
+     */
+    protected void visitAddIndex(final AlterTableStatement statement, final ParseTree ancestorNode) {
+        ParserRuleContext indexDefOptionNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(ancestorNode,
+                "addColumn");
+        if (null != indexDefOptionNode) {
+            ParserRuleContext indexNameNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(indexDefOptionNode,
+                    "indexName");
+            if (null != indexNameNode) {
+                statement.getSqlTokens().add(new IndexToken(indexNameNode.getStart().getStartIndex(),
+                        indexNameNode.getText(), statement.getTables().getSingleTableName()));
+            }
+        }
+    }
+
+    /**
+     * Visit drop index node.
+     * 
+     * @param statement
+     *            statement parse result
+     * @param ancestorNode
+     *            ancestor of index node
+     * @return indexName node
+     */
+    protected void visitDropIndex(final AlterTableStatement statement, final ParseTree ancestorNode) {
+        ParserRuleContext indexDefOptionNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(ancestorNode,
+                "alterDropIndex");
+        if (null != indexDefOptionNode) {
+            ParserRuleContext indexNameNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(indexDefOptionNode,
+                    "indexName");
+            if (null != indexNameNode) {
+                statement.getSqlTokens().add(new IndexToken(indexNameNode.getStart().getStartIndex(),
+                        indexNameNode.getText(), statement.getTables().getSingleTableName()));
+            }
+        }
+    }
+
+    /**
+     * Visit drop index node.
+     * 
+     * @param statement
+     *            statement parse result
+     * @param ancestorNode
+     *            ancestor of index node
+     * @return indexName node
+     */
+    protected void visitAddPrimaryKey(final AlterTableStatement statement, final ParseTree ancestorNode) {
+        ParserRuleContext addColumnCtx = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(ancestorNode,
+                "addColumn");
+
+        if (null == addColumnCtx) {
+            return;
+        }
+
+        List<ParseTree> alterColumnAddOptionCtxs = TreeUtils.getAllDescendantByRuleName(addColumnCtx,
+                "alterColumnAddOption");
+
+        if (null == alterColumnAddOptionCtxs) {
+            return;
+        }
+
+        for (ParseTree each : alterColumnAddOptionCtxs) {
+            ParserRuleContext primaryKeyNode = (ParserRuleContext) TreeUtils.getFirstChildByRuleName(each,
+                    "primaryKey");
+            if (null == primaryKeyNode) {
+                continue;
+            }
+
+            List<ParseTree> columnNameCtxs = TreeUtils.getAllDescendantByRuleName(each, "columnName");
+            for (ParseTree columnNameCtx : columnNameCtxs) {
+                statement.getUpdateColumns().put(columnNameCtx.getText(),
+                        new ColumnDefinition(columnNameCtx.getText(), null, null, true));
+            }
+        }
+    }
+}