Rename OptimizedStatement to SQLStatementContext (#3114)

* rename OptimizedStatement to SQLStatementContext

* rename Tables to TablesContext

* move tablecontext to table package

* rename InsertValue to InsertValueContext

* rename GroupBy to GroupByContext

* refactor PaginationTest

* rename OrderBy to OrderByContext

* rename Pagination to PaginationContext

* rename SelectItems to SelectItemsContext

sharding-core/sharding-core-entry/src/main/java/org/apache/shardingsphere/core/BaseShardingEngine.java

@@ -72,7 +72,7 @@ public abstract class BaseShardingEngine {
         boolean showSQL = shardingProperties.getValue(ShardingPropertiesConstant.SQL_SHOW);
         if (showSQL) {
             boolean showSimple = shardingProperties.getValue(ShardingPropertiesConstant.SQL_SIMPLE);
-            SQLLogger.logSQL(sql, showSimple, result.getShardingStatement(), result.getRouteUnits());
+            SQLLogger.logSQL(sql, showSimple, result.getShardingStatementContext(), result.getRouteUnits());
         }
         return result;
     }
@@ -108,7 +108,8 @@ public abstract class BaseShardingEngine {
                 sqlRouteResult, sql, parameters, sqlRouteResult.getRoutingResult().isSingleRouting(), shardingProperties.<Boolean>getValue(ShardingPropertiesConstant.QUERY_WITH_CIPHER_COLUMN));
         Collection<RouteUnit> result = new LinkedHashSet<>();
         for (RoutingUnit each : sqlRouteResult.getRoutingResult().getRoutingUnits()) {
-            result.add(new RouteUnit(each.getDataSourceName(), rewriteEngine.generateSQL(each, getLogicAndActualTables(each, sqlRouteResult.getShardingStatement().getTables().getTableNames()))));
+            result.add(new RouteUnit(
+                    each.getDataSourceName(), rewriteEngine.generateSQL(each, getLogicAndActualTables(each, sqlRouteResult.getShardingStatementContext().getTablesContext().getTableNames()))));
         }
         return result;
     }

sharding-core/sharding-core-entry/src/test/java/org/apache/shardingsphere/core/BaseShardingEngineTest.java

@@ -22,7 +22,7 @@ import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.api.hint.HintManager;
 import org.apache.shardingsphere.core.constant.properties.ShardingProperties;
 import org.apache.shardingsphere.core.constant.properties.ShardingPropertiesConstant;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.statement.dal.DALStatement;
 import org.apache.shardingsphere.core.route.RouteUnit;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
@@ -54,8 +54,8 @@ public abstract class BaseShardingEngineTest {
     }
     
     protected final SQLRouteResult createSQLRouteResult() {
-        SQLRouteResult result = new SQLRouteResult(new CommonOptimizedStatement(new DALStatement()), 
-                new CommonOptimizedStatement(new DALStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+        SQLRouteResult result = new SQLRouteResult(new CommonSQLStatementContext(new DALStatement()), 
+                new CommonSQLStatementContext(new DALStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         RoutingResult routingResult = new RoutingResult();
         routingResult.getRoutingUnits().add(new RoutingUnit("ds"));
         result.setRoutingResult(routingResult);

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/MergeEngineFactory.java

@@ -23,7 +23,7 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.dal.DALMergeEngine;
 import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.statement.dal.DALStatement;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
 import org.apache.shardingsphere.core.rule.ShardingRule;
@@ -54,11 +54,11 @@ public final class MergeEngineFactory {
      */
     public static MergeEngine newInstance(final DatabaseType databaseType, final ShardingRule shardingRule,
                                           final SQLRouteResult routeResult, final TableMetas tableMetas, final List<QueryResult> queryResults) throws SQLException {
-        if (routeResult.getShardingStatement() instanceof SelectOptimizedStatement) {
+        if (routeResult.getShardingStatementContext() instanceof SelectSQLStatementContext) {
             return new DQLMergeEngine(databaseType, tableMetas, routeResult, queryResults);
         } 
-        if (routeResult.getShardingStatement().getSqlStatement() instanceof DALStatement) {
-            return new DALMergeEngine(shardingRule, queryResults, routeResult.getShardingStatement(), tableMetas);
+        if (routeResult.getShardingStatementContext().getSqlStatement() instanceof DALStatement) {
+            return new DALMergeEngine(shardingRule, queryResults, routeResult.getShardingStatementContext(), tableMetas);
         }
         return new TransparentMergeEngine(queryResults);
     }

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/DALMergeEngine.java

@@ -29,7 +29,7 @@ import org.apache.shardingsphere.core.merge.dal.show.ShowOtherMergedResult;
 import org.apache.shardingsphere.core.merge.dal.show.ShowTableStatusMergedResult;
 import org.apache.shardingsphere.core.merge.dal.show.ShowTablesMergedResult;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.statement.SQLStatement;
 import org.apache.shardingsphere.core.parse.sql.statement.dal.dialect.mysql.DescribeStatement;
 import org.apache.shardingsphere.core.parse.sql.statement.dal.dialect.mysql.ShowCreateTableStatement;
@@ -55,13 +55,13 @@ public final class DALMergeEngine implements MergeEngine {
     
     private final List<QueryResult> queryResults;
     
-    private final OptimizedStatement optimizedStatement;
+    private final SQLStatementContext sqlStatementContext;
     
     private final TableMetas tableMetas;
     
     @Override
     public MergedResult merge() throws SQLException {
-        SQLStatement dalStatement = optimizedStatement.getSqlStatement();
+        SQLStatement dalStatement = sqlStatementContext.getSqlStatement();
         if (dalStatement instanceof ShowDatabasesStatement) {
             return new ShowDatabasesMergedResult();
         }
@@ -78,7 +78,7 @@ public final class DALMergeEngine implements MergeEngine {
             return new ShowIndexMergedResult(shardingRule, queryResults, tableMetas);
         }
         if (dalStatement instanceof DescribeStatement) {
-            return new DescribeTableMergedResult(shardingRule, queryResults, optimizedStatement);
+            return new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
         }
         return new ShowOtherMergedResult(queryResults.get(0));
     }

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/desc/DescribeTableMergedResult.java

@@ -21,7 +21,7 @@ import com.google.common.base.Optional;
 import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.dql.common.MemoryMergedResult;
 import org.apache.shardingsphere.core.merge.dql.common.MemoryQueryResultRow;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.rule.ShardingRule;
 import org.apache.shardingsphere.core.strategy.encrypt.EncryptTable;
 
@@ -52,14 +52,14 @@ public final class DescribeTableMergedResult extends MemoryMergedResult {
     
     private final ShardingRule shardingRule;
     
-    private final OptimizedStatement optimizedStatement;
+    private final SQLStatementContext sqlStatementContext;
     
     private final Iterator<MemoryQueryResultRow> memoryResultSetRows;
     
-    public DescribeTableMergedResult(final ShardingRule shardingRule, final List<QueryResult> queryResults, final OptimizedStatement optimizedStatement) throws SQLException {
+    public DescribeTableMergedResult(final ShardingRule shardingRule, final List<QueryResult> queryResults, final SQLStatementContext sqlStatementContext) throws SQLException {
         super(LABEL_AND_INDEX_MAP);
         this.shardingRule = shardingRule;
-        this.optimizedStatement = optimizedStatement;
+        this.sqlStatementContext = sqlStatementContext;
         this.memoryResultSetRows = init(queryResults);
     }
     
@@ -81,7 +81,7 @@ public final class DescribeTableMergedResult extends MemoryMergedResult {
     
     private Optional<MemoryQueryResultRow> optimize(final QueryResult queryResult) throws SQLException {
         MemoryQueryResultRow memoryQueryResultRow = new MemoryQueryResultRow(queryResult);
-        String logicTableName = optimizedStatement.getTables().getSingleTableName();
+        String logicTableName = sqlStatementContext.getTablesContext().getSingleTableName();
         Optional<EncryptTable> encryptTable = shardingRule.getEncryptRule().findEncryptTable(logicTableName);
         if (encryptTable.isPresent()) {
             String columnName = memoryQueryResultRow.getCell(1).toString();

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dql/DQLMergeEngine.java

@@ -35,8 +35,8 @@ import org.apache.shardingsphere.core.merge.dql.pagination.RowNumberDecoratorMer
 import org.apache.shardingsphere.core.merge.dql.pagination.TopAndRowNumberDecoratorMergedResult;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationDistinctSelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.util.SQLUtil;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
 import org.apache.shardingsphere.spi.database.DatabaseType;
@@ -58,7 +58,7 @@ public final class DQLMergeEngine implements MergeEngine {
     
     private final SQLRouteResult routeResult;
     
-    private final SelectOptimizedStatement shardingStatement;
+    private final SelectSQLStatementContext selectSQLStatementContext;
     
     private final List<QueryResult> queryResults;
     
@@ -68,7 +68,7 @@ public final class DQLMergeEngine implements MergeEngine {
     public DQLMergeEngine(final DatabaseType databaseType, final TableMetas tableMetas, final SQLRouteResult routeResult, final List<QueryResult> queryResults) throws SQLException {
         this.databaseType = databaseType;
         this.routeResult = routeResult;
-        this.shardingStatement = (SelectOptimizedStatement) routeResult.getShardingStatement();
+        this.selectSQLStatementContext = (SelectSQLStatementContext) routeResult.getShardingStatementContext();
         this.queryResults = getRealQueryResults(tableMetas, queryResults);
         columnLabelIndexMap = getColumnLabelIndexMap(this.queryResults.get(0));
     }
@@ -78,12 +78,12 @@ public final class DQLMergeEngine implements MergeEngine {
         if (1 == result.size()) {
             return result;
         }
-        List<AggregationDistinctSelectItem> aggregationDistinctSelectItems = shardingStatement.getSelectItems().getAggregationDistinctSelectItems();
+        List<AggregationDistinctSelectItem> aggregationDistinctSelectItems = selectSQLStatementContext.getSelectItemsContext().getAggregationDistinctSelectItems();
         if (!aggregationDistinctSelectItems.isEmpty()) {
             result = getDividedQueryResults(new AggregationDistinctQueryResult(queryResults, aggregationDistinctSelectItems));
         }
         if (isDistinctRowSelectItems()) {
-            result = getDividedQueryResults(new DistinctQueryResult(queryResults, shardingStatement.getColumnLabels(tableMetas)));
+            result = getDividedQueryResults(new DistinctQueryResult(queryResults, selectSQLStatementContext.getColumnLabels(tableMetas)));
         }
         return result.isEmpty() ? queryResults : result;
     }
@@ -99,7 +99,7 @@ public final class DQLMergeEngine implements MergeEngine {
     }
     
     private boolean isDistinctRowSelectItems() {
-        return shardingStatement.getSelectItems().isDistinctRow() && shardingStatement.getGroupBy().getItems().isEmpty();
+        return selectSQLStatementContext.getSelectItemsContext().isDistinctRow() && selectSQLStatementContext.getGroupByContext().getItems().isEmpty();
     }
     
     private Map<String, Integer> getColumnLabelIndexMap(final QueryResult queryResult) throws SQLException {
@@ -115,39 +115,40 @@ public final class DQLMergeEngine implements MergeEngine {
         if (1 == queryResults.size()) {
             return new IteratorStreamMergedResult(queryResults);
         }
-        shardingStatement.setIndexForItems(columnLabelIndexMap);
+        selectSQLStatementContext.setIndexForItems(columnLabelIndexMap);
         return decorate(build());
     }
     
     private MergedResult build() throws SQLException {
-        if (!shardingStatement.getGroupBy().getItems().isEmpty() || !shardingStatement.getSelectItems().getAggregationSelectItems().isEmpty()) {
+        if (!selectSQLStatementContext.getGroupByContext().getItems().isEmpty() || !selectSQLStatementContext.getSelectItemsContext().getAggregationSelectItems().isEmpty()) {
             return getGroupByMergedResult();
         }
-        if (!shardingStatement.getOrderBy().getItems().isEmpty()) {
-            return new OrderByStreamMergedResult(queryResults, shardingStatement.getOrderBy().getItems());
+        if (!selectSQLStatementContext.getOrderByContext().getItems().isEmpty()) {
+            return new OrderByStreamMergedResult(queryResults, selectSQLStatementContext.getOrderByContext().getItems());
         }
         return new IteratorStreamMergedResult(queryResults);
     }
     
     private MergedResult getGroupByMergedResult() throws SQLException {
-        return shardingStatement.isSameGroupByAndOrderByItems()
-                ? new GroupByStreamMergedResult(columnLabelIndexMap, queryResults, shardingStatement) : new GroupByMemoryMergedResult(columnLabelIndexMap, queryResults, shardingStatement);
+        return selectSQLStatementContext.isSameGroupByAndOrderByItems()
+                ? new GroupByStreamMergedResult(columnLabelIndexMap, queryResults, selectSQLStatementContext)
+                : new GroupByMemoryMergedResult(columnLabelIndexMap, queryResults, selectSQLStatementContext);
     }
     
     private MergedResult decorate(final MergedResult mergedResult) throws SQLException {
-        Pagination pagination = ((SelectOptimizedStatement) routeResult.getShardingStatement()).getPagination();
-        if (!pagination.isHasPagination() || 1 == queryResults.size()) {
+        PaginationContext paginationContext = ((SelectSQLStatementContext) routeResult.getShardingStatementContext()).getPaginationContext();
+        if (!paginationContext.isHasPagination() || 1 == queryResults.size()) {
             return mergedResult;
         }
         String trunkDatabaseName = DatabaseTypes.getTrunkDatabaseType(databaseType.getName()).getName();
         if ("MySQL".equals(trunkDatabaseName) || "PostgreSQL".equals(trunkDatabaseName)) {
-            return new LimitDecoratorMergedResult(mergedResult, pagination);
+            return new LimitDecoratorMergedResult(mergedResult, paginationContext);
         }
         if ("Oracle".equals(trunkDatabaseName)) {
-            return new RowNumberDecoratorMergedResult(mergedResult, pagination);
+            return new RowNumberDecoratorMergedResult(mergedResult, paginationContext);
         }
         if ("SQLServer".equals(trunkDatabaseName)) {
-            return new TopAndRowNumberDecoratorMergedResult(mergedResult, pagination);
+            return new TopAndRowNumberDecoratorMergedResult(mergedResult, paginationContext);
         }
         return mergedResult;
     }

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByMemoryMergedResult.java

@@ -27,7 +27,7 @@ import org.apache.shardingsphere.core.merge.dql.common.MemoryQueryResultRow;
 import org.apache.shardingsphere.core.merge.dql.groupby.aggregation.AggregationUnit;
 import org.apache.shardingsphere.core.merge.dql.groupby.aggregation.AggregationUnitFactory;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationSelectItem;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -46,14 +46,14 @@ import java.util.Map.Entry;
  */
 public final class GroupByMemoryMergedResult extends MemoryMergedResult {
     
-    private final SelectOptimizedStatement optimizedStatement;
+    private final SelectSQLStatementContext selectSQLStatementContext;
     
     private final Iterator<MemoryQueryResultRow> memoryResultSetRows;
     
     public GroupByMemoryMergedResult(
-            final Map<String, Integer> labelAndIndexMap, final List<QueryResult> queryResults, final SelectOptimizedStatement optimizedStatement) throws SQLException {
+            final Map<String, Integer> labelAndIndexMap, final List<QueryResult> queryResults, final SelectSQLStatementContext selectSQLStatementContext) throws SQLException {
         super(labelAndIndexMap);
-        this.optimizedStatement = optimizedStatement;
+        this.selectSQLStatementContext = selectSQLStatementContext;
         memoryResultSetRows = init(queryResults);
     }
     
@@ -62,7 +62,7 @@ public final class GroupByMemoryMergedResult extends MemoryMergedResult {
         Map<GroupByValue, Map<AggregationSelectItem, AggregationUnit>> aggregationMap = new HashMap<>(1024);
         for (QueryResult each : queryResults) {
             while (each.next()) {
-                GroupByValue groupByValue = new GroupByValue(each, optimizedStatement.getGroupBy().getItems());
+                GroupByValue groupByValue = new GroupByValue(each, selectSQLStatementContext.getGroupByContext().getItems());
                 initForFirstGroupByValue(each, groupByValue, dataMap, aggregationMap);
                 aggregate(each, groupByValue, aggregationMap);
             }
@@ -82,7 +82,8 @@ public final class GroupByMemoryMergedResult extends MemoryMergedResult {
             dataMap.put(groupByValue, new MemoryQueryResultRow(queryResult));
         }
         if (!aggregationMap.containsKey(groupByValue)) {
-            Map<AggregationSelectItem, AggregationUnit> map = Maps.toMap(optimizedStatement.getSelectItems().getAggregationSelectItems(), new Function<AggregationSelectItem, AggregationUnit>() {
+            Map<AggregationSelectItem, AggregationUnit> map = Maps.toMap(
+                    selectSQLStatementContext.getSelectItemsContext().getAggregationSelectItems(), new Function<AggregationSelectItem, AggregationUnit>() {
                 
                 @Override
                 public AggregationUnit apply(final AggregationSelectItem input) {
@@ -94,7 +95,7 @@ public final class GroupByMemoryMergedResult extends MemoryMergedResult {
     }
     
     private void aggregate(final QueryResult queryResult, final GroupByValue groupByValue, final Map<GroupByValue, Map<AggregationSelectItem, AggregationUnit>> aggregationMap) throws SQLException {
-        for (AggregationSelectItem each : optimizedStatement.getSelectItems().getAggregationSelectItems()) {
+        for (AggregationSelectItem each : selectSQLStatementContext.getSelectItemsContext().getAggregationSelectItems()) {
             List<Comparable<?>> values = new ArrayList<>(2);
             if (each.getDerivedAggregationItems().isEmpty()) {
                 values.add(getAggregationValue(queryResult, each));
@@ -115,7 +116,7 @@ public final class GroupByMemoryMergedResult extends MemoryMergedResult {
     
     private void setAggregationValueToMemoryRow(final Map<GroupByValue, MemoryQueryResultRow> dataMap, final Map<GroupByValue, Map<AggregationSelectItem, AggregationUnit>> aggregationMap) {
         for (Entry<GroupByValue, MemoryQueryResultRow> entry : dataMap.entrySet()) {
-            for (AggregationSelectItem each : optimizedStatement.getSelectItems().getAggregationSelectItems()) {
+            for (AggregationSelectItem each : selectSQLStatementContext.getSelectItemsContext().getAggregationSelectItems()) {
                 entry.getValue().setCell(each.getIndex(), aggregationMap.get(entry.getKey()).get(each).getResult());
             }
         }
@@ -131,7 +132,7 @@ public final class GroupByMemoryMergedResult extends MemoryMergedResult {
     
     private List<MemoryQueryResultRow> getMemoryResultSetRows(final Map<GroupByValue, MemoryQueryResultRow> dataMap, final List<Boolean> valueCaseSensitive) {
         List<MemoryQueryResultRow> result = new ArrayList<>(dataMap.values());
-        Collections.sort(result, new GroupByRowComparator(optimizedStatement, valueCaseSensitive));
+        Collections.sort(result, new GroupByRowComparator(selectSQLStatementContext, valueCaseSensitive));
         return result;
     }
     

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByRowComparator.java

@@ -22,7 +22,7 @@ import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.core.merge.dql.common.MemoryQueryResultRow;
 import org.apache.shardingsphere.core.merge.dql.orderby.CompareUtil;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 
 import java.util.Collection;
 import java.util.Comparator;
@@ -37,16 +37,16 @@ import java.util.List;
 @RequiredArgsConstructor
 public final class GroupByRowComparator implements Comparator<MemoryQueryResultRow> {
     
-    private final SelectOptimizedStatement optimizedStatement;
+    private final SelectSQLStatementContext selectSQLStatementContext;
     
     private final List<Boolean> valueCaseSensitive;
     
     @Override
     public int compare(final MemoryQueryResultRow o1, final MemoryQueryResultRow o2) {
-        if (!optimizedStatement.getOrderBy().getItems().isEmpty()) {
-            return compare(o1, o2, optimizedStatement.getOrderBy().getItems());
+        if (!selectSQLStatementContext.getOrderByContext().getItems().isEmpty()) {
+            return compare(o1, o2, selectSQLStatementContext.getOrderByContext().getItems());
         }
-        return compare(o1, o2, optimizedStatement.getGroupBy().getItems());
+        return compare(o1, o2, selectSQLStatementContext.getGroupByContext().getItems());
     }
     
     private int compare(final MemoryQueryResultRow o1, final MemoryQueryResultRow o2, final Collection<OrderByItem> orderByItems) {

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByStreamMergedResult.java

@@ -25,7 +25,7 @@ import org.apache.shardingsphere.core.merge.dql.groupby.aggregation.AggregationU
 import org.apache.shardingsphere.core.merge.dql.groupby.aggregation.AggregationUnitFactory;
 import org.apache.shardingsphere.core.merge.dql.orderby.OrderByStreamMergedResult;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationSelectItem;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -44,20 +44,20 @@ public final class GroupByStreamMergedResult extends OrderByStreamMergedResult {
     
     private final Map<String, Integer> labelAndIndexMap;
     
-    private final SelectOptimizedStatement optimizedStatement;
+    private final SelectSQLStatementContext selectSQLStatementContext;
     
     private final List<Object> currentRow;
     
     private List<?> currentGroupByValues;
     
     public GroupByStreamMergedResult(
-            final Map<String, Integer> labelAndIndexMap, final List<QueryResult> queryResults, final SelectOptimizedStatement optimizedStatement) throws SQLException {
-        super(queryResults, optimizedStatement.getOrderBy().getItems());
+            final Map<String, Integer> labelAndIndexMap, final List<QueryResult> queryResults, final SelectSQLStatementContext selectSQLStatementContext) throws SQLException {
+        super(queryResults, selectSQLStatementContext.getOrderByContext().getItems());
         this.labelAndIndexMap = labelAndIndexMap;
-        this.optimizedStatement = optimizedStatement;
+        this.selectSQLStatementContext = selectSQLStatementContext;
         currentRow = new ArrayList<>(labelAndIndexMap.size());
         currentGroupByValues = getOrderByValuesQueue().isEmpty()
-                ? Collections.emptyList() : new GroupByValue(getCurrentQueryResult(), optimizedStatement.getGroupBy().getItems()).getGroupValues();
+                ? Collections.emptyList() : new GroupByValue(getCurrentQueryResult(), selectSQLStatementContext.getGroupByContext().getItems()).getGroupValues();
     }
     
     @Override
@@ -70,7 +70,7 @@ public final class GroupByStreamMergedResult extends OrderByStreamMergedResult {
             super.next();
         }
         if (aggregateCurrentGroupByRowAndNext()) {
-            currentGroupByValues = new GroupByValue(getCurrentQueryResult(), optimizedStatement.getGroupBy().getItems()).getGroupValues();
+            currentGroupByValues = new GroupByValue(getCurrentQueryResult(), selectSQLStatementContext.getGroupByContext().getItems()).getGroupValues();
         }
         return true;
     }
@@ -78,14 +78,14 @@ public final class GroupByStreamMergedResult extends OrderByStreamMergedResult {
     private boolean aggregateCurrentGroupByRowAndNext() throws SQLException {
         boolean result = false;
         Map<AggregationSelectItem, AggregationUnit> aggregationUnitMap = Maps.toMap(
-                optimizedStatement.getSelectItems().getAggregationSelectItems(), new Function<AggregationSelectItem, AggregationUnit>() {
+                selectSQLStatementContext.getSelectItemsContext().getAggregationSelectItems(), new Function<AggregationSelectItem, AggregationUnit>() {
                     
                     @Override
                     public AggregationUnit apply(final AggregationSelectItem input) {
                         return AggregationUnitFactory.create(input.getType());
                     }
                 });
-        while (currentGroupByValues.equals(new GroupByValue(getCurrentQueryResult(), optimizedStatement.getGroupBy().getItems()).getGroupValues())) {
+        while (currentGroupByValues.equals(new GroupByValue(getCurrentQueryResult(), selectSQLStatementContext.getGroupByContext().getItems()).getGroupValues())) {
             aggregate(aggregationUnitMap);
             cacheCurrentRow();
             result = super.next();

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dql/pagination/LimitDecoratorMergedResult.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.core.merge.dql.pagination;
 
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.common.DecoratorMergedResult;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
 
 import java.sql.SQLException;
 
@@ -30,13 +30,13 @@ import java.sql.SQLException;
  */
 public final class LimitDecoratorMergedResult extends DecoratorMergedResult {
     
-    private final Pagination pagination;
+    private final PaginationContext pagination;
     
     private final boolean skipAll;
     
     private int rowNumber;
     
-    public LimitDecoratorMergedResult(final MergedResult mergedResult, final Pagination pagination) throws SQLException {
+    public LimitDecoratorMergedResult(final MergedResult mergedResult, final PaginationContext pagination) throws SQLException {
         super(mergedResult);
         this.pagination = pagination;
         skipAll = skipOffset();

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dql/pagination/RowNumberDecoratorMergedResult.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.core.merge.dql.pagination;
 
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.common.DecoratorMergedResult;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
 
 import java.sql.SQLException;
 
@@ -30,13 +30,13 @@ import java.sql.SQLException;
  */
 public final class RowNumberDecoratorMergedResult extends DecoratorMergedResult {
     
-    private final Pagination pagination;
+    private final PaginationContext pagination;
     
     private final boolean skipAll;
     
     private long rowNumber;
     
-    public RowNumberDecoratorMergedResult(final MergedResult mergedResult, final Pagination pagination) throws SQLException {
+    public RowNumberDecoratorMergedResult(final MergedResult mergedResult, final PaginationContext pagination) throws SQLException {
         super(mergedResult);
         this.pagination = pagination;
         skipAll = skipOffset();

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dql/pagination/TopAndRowNumberDecoratorMergedResult.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.core.merge.dql.pagination;
 
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.common.DecoratorMergedResult;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
 
 import java.sql.SQLException;
 
@@ -30,13 +30,13 @@ import java.sql.SQLException;
  */
 public final class TopAndRowNumberDecoratorMergedResult extends DecoratorMergedResult {
     
-    private final Pagination pagination;
+    private final PaginationContext pagination;
     
     private final boolean skipAll;
     
     private long rowNumber;
     
-    public TopAndRowNumberDecoratorMergedResult(final MergedResult mergedResult, final Pagination pagination) throws SQLException {
+    public TopAndRowNumberDecoratorMergedResult(final MergedResult mergedResult, final PaginationContext pagination) throws SQLException {
         super(mergedResult);
         this.pagination = pagination;
         skipAll = skipOffset();

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/MergeEngineFactoryTest.java

@@ -23,15 +23,15 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.dal.DALMergeEngine;
 import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.generic.TableSegment;
 import org.apache.shardingsphere.core.parse.sql.statement.dal.DALStatement;
@@ -74,17 +74,17 @@ public final class MergeEngineFactoryTest {
     @Test
     public void assertNewInstanceWithSelectStatement() throws SQLException {
         SQLRouteResult routeResult = new SQLRouteResult(
-                new SelectOptimizedStatement(new SelectStatement(), 
-                        new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false),
-                        new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList())), 
-                new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                new SelectSQLStatementContext(new SelectStatement(), 
+                        new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
+                        new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList())), 
+                new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         assertThat(MergeEngineFactory.newInstance(DatabaseTypes.getActualDatabaseType("MySQL"), null, routeResult, null, queryResults), instanceOf(DQLMergeEngine.class));
     }
     
     @Test
     public void assertNewInstanceWithDALStatement() throws SQLException {
-        SQLRouteResult routeResult = new SQLRouteResult(new CommonOptimizedStatement(new DALStatement()), 
-                new CommonOptimizedStatement(new DALStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+        SQLRouteResult routeResult = new SQLRouteResult(new CommonSQLStatementContext(new DALStatement()), 
+                new CommonSQLStatementContext(new DALStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         assertThat(MergeEngineFactory.newInstance(DatabaseTypes.getActualDatabaseType("MySQL"), null, routeResult, null, queryResults), instanceOf(DALMergeEngine.class));
     }
     
@@ -94,8 +94,8 @@ public final class MergeEngineFactoryTest {
         insertStatement.getAllSQLSegments().add(new TableSegment(0, 0, "tbl"));
         insertStatement.getColumns().add(new ColumnSegment(0, 0, "col"));
         SQLRouteResult routeResult = new SQLRouteResult(
-                new InsertOptimizedStatement(null, Collections.emptyList(), insertStatement), 
-                new CommonOptimizedStatement(insertStatement), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                new InsertSQLStatementContext(null, Collections.emptyList(), insertStatement), 
+                new CommonSQLStatementContext(insertStatement), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         assertThat(MergeEngineFactory.newInstance(DatabaseTypes.getActualDatabaseType("MySQL"), null, routeResult, null, queryResults), instanceOf(TransparentMergeEngine.class));
     }
 }

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/DALMergeEngineTest.java

@@ -24,7 +24,7 @@ import org.apache.shardingsphere.core.merge.dal.show.ShowDatabasesMergedResult;
 import org.apache.shardingsphere.core.merge.dal.show.ShowOtherMergedResult;
 import org.apache.shardingsphere.core.merge.dal.show.ShowTablesMergedResult;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.statement.dal.DALStatement;
 import org.apache.shardingsphere.core.parse.sql.statement.dal.dialect.mysql.DescribeStatement;
 import org.apache.shardingsphere.core.parse.sql.statement.dal.dialect.mysql.ShowCreateTableStatement;
@@ -57,46 +57,46 @@ public final class DALMergeEngineTest {
     @Test
     public void assertMergeForShowDatabasesStatement() throws SQLException {
         DALStatement dalStatement = new ShowDatabasesStatement();
-        OptimizedStatement optimizedStatement = mockOptimizedStatement(dalStatement);
-        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, optimizedStatement, null);
+        SQLStatementContext sqlStatementContext = mockSQLStatementContext(dalStatement);
+        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, sqlStatementContext, null);
         assertThat(dalMergeEngine.merge(), instanceOf(ShowDatabasesMergedResult.class));
     }
     
     @Test
     public void assertMergeForShowShowTablesStatement() throws SQLException {
         DALStatement dalStatement = new ShowTablesStatement();
-        OptimizedStatement optimizedStatement = mockOptimizedStatement(dalStatement);
-        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, optimizedStatement, null);
+        SQLStatementContext sqlStatementContext = mockSQLStatementContext(dalStatement);
+        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, sqlStatementContext, null);
         assertThat(dalMergeEngine.merge(), instanceOf(ShowTablesMergedResult.class));
     }
     
     @Test
     public void assertMergeForShowCreateTableStatement() throws SQLException {
         DALStatement dalStatement = new ShowCreateTableStatement();
-        OptimizedStatement optimizedStatement = mockOptimizedStatement(dalStatement);
-        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, optimizedStatement, null);
+        SQLStatementContext sqlStatementContext = mockSQLStatementContext(dalStatement);
+        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, sqlStatementContext, null);
         assertThat(dalMergeEngine.merge(), instanceOf(ShowCreateTableMergedResult.class));
     }
     
     @Test
     public void assertMergeForShowOtherStatement() throws SQLException {
         DALStatement dalStatement = new ShowOtherStatement();
-        OptimizedStatement optimizedStatement = mockOptimizedStatement(dalStatement);
-        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, optimizedStatement, null);
+        SQLStatementContext sqlStatementContext = mockSQLStatementContext(dalStatement);
+        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, sqlStatementContext, null);
         assertThat(dalMergeEngine.merge(), instanceOf(ShowOtherMergedResult.class));
     }
     
     @Test
     public void assertMergeForDescribeStatement() throws SQLException {
         DALStatement dalStatement = new DescribeStatement();
-        OptimizedStatement optimizedStatement = mockOptimizedStatement(dalStatement);
-        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, optimizedStatement, null);
+        SQLStatementContext sqlStatementContext = mockSQLStatementContext(dalStatement);
+        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, sqlStatementContext, null);
         assertThat(dalMergeEngine.merge(), instanceOf(DescribeTableMergedResult.class));
     }
     
-    private OptimizedStatement mockOptimizedStatement(final DALStatement dalStatement) {
-        OptimizedStatement optimizedStatement = mock(OptimizedStatement.class);
-        when(optimizedStatement.getSqlStatement()).thenReturn(dalStatement);
-        return optimizedStatement;
+    private SQLStatementContext mockSQLStatementContext(final DALStatement dalStatement) {
+        SQLStatementContext result = mock(SQLStatementContext.class);
+        when(result.getSqlStatement()).thenReturn(dalStatement);
+        return result;
     }
 }

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/desc/DescribeTableMergedResultTest.java

@@ -21,8 +21,8 @@ import com.google.common.base.Optional;
 import com.google.common.collect.Lists;
 import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.fixture.DescribeQueryResultFixture;
-import org.apache.shardingsphere.core.optimize.segment.Tables;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.table.TablesContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.rule.EncryptRule;
 import org.apache.shardingsphere.core.rule.ShardingRule;
 import org.apache.shardingsphere.core.strategy.encrypt.EncryptTable;
@@ -44,14 +44,14 @@ public final class DescribeTableMergedResultTest {
 
     private List<QueryResult> queryResults;
 
-    private OptimizedStatement optimizedStatement;
+    private SQLStatementContext sqlStatementContext;
 
     @Before
     public void setUp() throws SQLException {
-        optimizedStatement = mock(OptimizedStatement.class);
-        Tables tables = mock(Tables.class);
-        when(tables.getSingleTableName()).thenReturn("user");
-        when(optimizedStatement.getTables()).thenReturn(tables);
+        sqlStatementContext = mock(SQLStatementContext.class);
+        TablesContext tablesContext = mock(TablesContext.class);
+        when(tablesContext.getSingleTableName()).thenReturn("user");
+        when(sqlStatementContext.getTablesContext()).thenReturn(tablesContext);
         List<QueryResult> mockQueryResults = mockQueryResults();
         QueryResult queryResult = new DescribeQueryResultFixture(mockQueryResults.iterator());
         queryResults = Lists.newArrayList(queryResult);
@@ -101,14 +101,14 @@ public final class DescribeTableMergedResultTest {
     public void assertNextForEmptyQueryResult() throws SQLException {
         ShardingRule shardingRule = mock(ShardingRule.class);
         List<QueryResult> queryResults = Collections.emptyList();
-        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, optimizedStatement);
+        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
         assertFalse(describeTableMergedResult.next());
     }
 
     @Test
     public void assertFieldWithEncryptRule() throws SQLException {
         ShardingRule shardingRule = mockShardingRuleWithEncryptRule();
-        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, optimizedStatement);
+        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
         assertTrue(describeTableMergedResult.next());
         assertEquals(describeTableMergedResult.getValue(1, String.class), "id");
         assertEquals(describeTableMergedResult.getValue("Field", String.class), "id");
@@ -124,7 +124,7 @@ public final class DescribeTableMergedResultTest {
     @Test
     public void assertFieldWithoutEncryptRule() throws SQLException {
         ShardingRule shardingRule = mockShardingRuleWithoutEncryptRule();
-        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, optimizedStatement);
+        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
         assertTrue(describeTableMergedResult.next());
         assertEquals(describeTableMergedResult.getValue(1, String.class), "id");
         assertEquals(describeTableMergedResult.getValue("Field", String.class), "id");
@@ -142,7 +142,7 @@ public final class DescribeTableMergedResultTest {
     @Test
     public void assertAllWithoutEncryptRule() throws SQLException {
         ShardingRule shardingRule = mockShardingRuleWithoutEncryptRule();
-        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, optimizedStatement);
+        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
         assertTrue(describeTableMergedResult.next());
         assertEquals(describeTableMergedResult.getValue(1, String.class), "id");
         assertEquals(describeTableMergedResult.getValue("Field", String.class), "id");
@@ -161,7 +161,7 @@ public final class DescribeTableMergedResultTest {
     @Test
     public void assertAllWithEncryptRule() throws SQLException {
         ShardingRule shardingRule = mockShardingRuleWithEncryptRule();
-        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, optimizedStatement);
+        DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
         assertTrue(describeTableMergedResult.next());
         assertEquals(describeTableMergedResult.getValue(1, String.class), "id");
         assertEquals(describeTableMergedResult.getValue("Field", String.class), "id");

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByMemoryMergedResultTest.java

@@ -23,16 +23,16 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.core.constant.AggregationType;
 import org.apache.shardingsphere.core.parse.core.constant.OrderDirection;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.IndexOrderByItemSegment;
@@ -86,12 +86,12 @@ public final class GroupByMemoryMergedResultTest {
         AggregationSelectItem derivedAggregationSelectItem2 = new AggregationSelectItem(AggregationType.SUM, "(num)", "AVG_DERIVED_SUM_0");
         aggregationSelectItem2.setIndex(5);
         aggregationSelectItem2.getDerivedAggregationItems().add(derivedAggregationSelectItem2);
-        SelectItems selectItems = new SelectItems(0, 0, false, Arrays.<SelectItem>asList(aggregationSelectItem1, aggregationSelectItem2));
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.singletonList(createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), 0),
-                new OrderBy(Collections.singletonList(createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.DESC, OrderDirection.ASC))), false),
-                selectItems, new Pagination(null, null, Collections.emptyList()));
-        routeResult = new SQLRouteResult(shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, false, Arrays.<SelectItem>asList(aggregationSelectItem1, aggregationSelectItem2));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.singletonList(createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), 0),
+                new OrderByContext(Collections.singletonList(createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.DESC, OrderDirection.ASC))), false),
+                selectItemsContext, new PaginationContext(null, null, Collections.emptyList()));
+        routeResult = new SQLRouteResult(selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
     }
     
     private ResultSet mockResultSet() throws SQLException {

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByRowComparatorTest.java

@@ -21,13 +21,13 @@ import com.google.common.collect.Lists;
 import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.dql.common.MemoryQueryResultRow;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.core.constant.OrderDirection;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.IndexOrderByItemSegment;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.SelectStatement;
@@ -52,15 +52,15 @@ public final class GroupByRowComparatorTest {
     
     @Test
     public void assertCompareToForAscWithOrderByItems() throws SQLException {
-        SelectOptimizedStatement optimizedStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Arrays.asList(
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Arrays.asList(
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.ASC)), 
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), 0),
-                new OrderBy(Arrays.asList(
+                new OrderByContext(Arrays.asList(
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.ASC, OrderDirection.ASC))), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList()));
-        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(optimizedStatement, caseSensitives);
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
+        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
         MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
         MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("3", "4"));
         assertTrue(groupByRowComparator.compare(o1, o2) < 0);
@@ -68,15 +68,15 @@ public final class GroupByRowComparatorTest {
     
     @Test
     public void assertCompareToForDecsWithOrderByItems() throws SQLException {
-        SelectOptimizedStatement optimizedStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Arrays.asList(
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Arrays.asList(
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.ASC, OrderDirection.ASC))), 0),
-                new OrderBy(Arrays.asList(
+                new OrderByContext(Arrays.asList(
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.ASC)),
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList()));
-        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(optimizedStatement, caseSensitives);
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
+        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
         MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
         MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("3", "4"));
         assertTrue(groupByRowComparator.compare(o1, o2) > 0);
@@ -84,15 +84,15 @@ public final class GroupByRowComparatorTest {
     
     @Test
     public void assertCompareToForEqualWithOrderByItems() throws SQLException {
-        SelectOptimizedStatement optimizedStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Arrays.asList(
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Arrays.asList(
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.ASC)),
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.ASC, OrderDirection.ASC))), 0),
-                new OrderBy(Arrays.asList(
+                new OrderByContext(Arrays.asList(
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList()));
-        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(optimizedStatement, caseSensitives);
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
+        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
         MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
         MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
         assertThat(groupByRowComparator.compare(o1, o2), is(0));
@@ -100,12 +100,12 @@ public final class GroupByRowComparatorTest {
     
     @Test
     public void assertCompareToForAscWithGroupByItems() throws SQLException {
-        SelectOptimizedStatement optimizedStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Arrays.asList(
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Arrays.asList(
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
-                        createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.ASC, OrderDirection.ASC))), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList()));
-        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(optimizedStatement, caseSensitives);
+                        createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.ASC, OrderDirection.ASC))), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
+        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
         MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
         MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("3", "4"));
         assertTrue(groupByRowComparator.compare(o1, o2) < 0);
@@ -113,12 +113,12 @@ public final class GroupByRowComparatorTest {
     
     @Test
     public void assertCompareToForDecsWithGroupByItems() throws SQLException {
-        SelectOptimizedStatement optimizedStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Arrays.asList(
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Arrays.asList(
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.ASC)),
-                        createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList()));
-        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(optimizedStatement, caseSensitives);
+                        createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
+        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
         MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
         MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("3", "4"));
         assertTrue(groupByRowComparator.compare(o1, o2) > 0);
@@ -126,12 +126,12 @@ public final class GroupByRowComparatorTest {
     
     @Test
     public void assertCompareToForEqualWithGroupByItems() throws SQLException {
-        SelectOptimizedStatement optimizedStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Arrays.asList(
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Arrays.asList(
                         createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
-                        createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList()));
-        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(optimizedStatement, caseSensitives);
+                        createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
+        GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
         MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
         MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
         assertThat(groupByRowComparator.compare(o1, o2), is(0));

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByStreamMergedResultTest.java

@@ -23,16 +23,16 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.core.constant.AggregationType;
 import org.apache.shardingsphere.core.parse.core.constant.OrderDirection;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.IndexOrderByItemSegment;
@@ -88,12 +88,12 @@ public final class GroupByStreamMergedResultTest {
         AggregationSelectItem derivedAggregationSelectItem2 = new AggregationSelectItem(AggregationType.SUM, "(num)", "AVG_DERIVED_SUM_0");
         aggregationSelectItem2.setIndex(6);
         aggregationSelectItem2.getDerivedAggregationItems().add(derivedAggregationSelectItem2);
-        SelectItems selectItems = new SelectItems(0, 0, false, Arrays.<SelectItem>asList(aggregationSelectItem1, aggregationSelectItem2));
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), 0),
-                new OrderBy(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), false),
-                selectItems, new Pagination(null, null, Collections.emptyList()));
-        routeResult = new SQLRouteResult(shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, false, Arrays.<SelectItem>asList(aggregationSelectItem1, aggregationSelectItem2));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), 0),
+                new OrderByContext(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), false),
+                selectItemsContext, new PaginationContext(null, null, Collections.emptyList()));
+        routeResult = new SQLRouteResult(selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
     }
     
     private ResultSet mockResultSet() throws SQLException {

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/iterator/IteratorStreamMergedResultTest.java

@@ -23,14 +23,14 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.SelectStatement;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
 import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingCondition;
@@ -63,10 +63,10 @@ public final class IteratorStreamMergedResultTest {
         ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
         when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
         queryResults = Lists.<QueryResult>newArrayList(new TestQueryResult(resultSet), new TestQueryResult(mock(ResultSet.class)), new TestQueryResult(mock(ResultSet.class)));
-        routeResult = new SQLRouteResult(new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false), 
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList())), 
-                new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+        routeResult = new SQLRouteResult(new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false), 
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList())), 
+                new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
     }
     
     @Test

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/orderby/OrderByStreamMergedResultTest.java

@@ -23,15 +23,15 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.core.constant.OrderDirection;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.IndexOrderByItemSegment;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.SelectStatement;
@@ -66,11 +66,11 @@ public final class OrderByStreamMergedResultTest {
     public void setUp() throws SQLException {
         queryResults = Lists.<QueryResult>newArrayList(
                 new TestQueryResult(mockResultSet()), new TestQueryResult(mockResultSet()), new TestQueryResult(mockResultSet()));
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), 
-                new OrderBy(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC))), false), 
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList()));
-        routeResult = new SQLRouteResult(shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), 
+                new OrderByContext(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC))), false), 
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
+        routeResult = new SQLRouteResult(selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
     }
     
     private ResultSet mockResultSet() throws SQLException {

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/pagination/LimitDecoratorMergedResultTest.java

@@ -23,15 +23,15 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.limit.NumberLiteralLimitValueSegment;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.SelectStatement;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
@@ -75,12 +75,12 @@ public final class LimitDecoratorMergedResultTest {
     
     @Test
     public void assertNextForSkipAll() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), 
-                new Pagination(new NumberLiteralLimitValueSegment(0, 0, Integer.MAX_VALUE), null, Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), 
+                new PaginationContext(new NumberLiteralLimitValueSegment(0, 0, Integer.MAX_VALUE), null, Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         assertFalse(actual.next());
@@ -88,12 +88,12 @@ public final class LimitDecoratorMergedResultTest {
     
     @Test
     public void assertNextWithoutRowCount() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), 
-                new Pagination(new NumberLiteralLimitValueSegment(0, 0, 2), null, Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), 
+                new PaginationContext(new NumberLiteralLimitValueSegment(0, 0, 2), null, Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         for (int i = 0; i < 6; i++) {
@@ -104,12 +104,12 @@ public final class LimitDecoratorMergedResultTest {
     
     @Test
     public void assertNextWithRowCount() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false), 
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()),
-                new Pagination(new NumberLiteralLimitValueSegment(0, 0, 2), new NumberLiteralLimitValueSegment(0, 0, 2), Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false), 
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()),
+                new PaginationContext(new NumberLiteralLimitValueSegment(0, 0, 2), new NumberLiteralLimitValueSegment(0, 0, 2), Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         assertTrue(actual.next());

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/pagination/RowNumberDecoratorMergedResultTest.java

@@ -23,15 +23,15 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.rownum.NumberLiteralRowNumberValueSegment;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.SelectStatement;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
@@ -75,12 +75,12 @@ public final class RowNumberDecoratorMergedResultTest {
     
     @Test
     public void assertNextForSkipAll() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false), 
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()),
-                new Pagination(new NumberLiteralRowNumberValueSegment(0, 0, Integer.MAX_VALUE, true), null, Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false), 
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()),
+                new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, Integer.MAX_VALUE, true), null, Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         assertFalse(actual.next());
@@ -88,11 +88,11 @@ public final class RowNumberDecoratorMergedResultTest {
     
     @Test
     public void assertNextWithoutOffsetWithoutRowCount() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), new Pagination(null, null, Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         for (int i = 0; i < 8; i++) {
@@ -103,12 +103,12 @@ public final class RowNumberDecoratorMergedResultTest {
     
     @Test
     public void assertNextForRowCountBoundOpenedFalse() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false), 
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()),
-                new Pagination(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), new NumberLiteralRowNumberValueSegment(0, 0, 4, false), Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false), 
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()),
+                new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), new NumberLiteralRowNumberValueSegment(0, 0, 4, false), Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         assertTrue(actual.next());
@@ -118,12 +118,12 @@ public final class RowNumberDecoratorMergedResultTest {
     
     @Test
     public void assertNextForRowCountBoundOpenedTrue() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false), 
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()),
-                new Pagination(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), new NumberLiteralRowNumberValueSegment(0, 0, 4, true), Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false), 
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()),
+                new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), new NumberLiteralRowNumberValueSegment(0, 0, 4, true), Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         assertTrue(actual.next());

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/pagination/TopAndRowNumberDecoratorMergedResultTest.java

@@ -23,15 +23,15 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
 import org.apache.shardingsphere.core.merge.fixture.TestQueryResult;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.limit.NumberLiteralLimitValueSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.rownum.NumberLiteralRowNumberValueSegment;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.SelectStatement;
@@ -76,12 +76,12 @@ public final class TopAndRowNumberDecoratorMergedResultTest {
     
     @Test
     public void assertNextForSkipAll() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false), 
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()),
-                new Pagination(new NumberLiteralRowNumberValueSegment(0, 0, Integer.MAX_VALUE, true), null, Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false), 
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()),
+                new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, Integer.MAX_VALUE, true), null, Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         assertFalse(actual.next());
@@ -89,12 +89,12 @@ public final class TopAndRowNumberDecoratorMergedResultTest {
     
     @Test
     public void assertNextWithoutOffsetWithRowCount() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), 
-                new Pagination(null, new NumberLiteralLimitValueSegment(0, 0, 5), Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), 
+                new PaginationContext(null, new NumberLiteralLimitValueSegment(0, 0, 5), Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         for (int i = 0; i < 5; i++) {
@@ -105,12 +105,12 @@ public final class TopAndRowNumberDecoratorMergedResultTest {
     
     @Test
     public void assertNextWithOffsetWithoutRowCount() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false),
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()), 
-                new Pagination(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), null, Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()), 
+                new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), null, Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         for (int i = 0; i < 7; i++) {
@@ -121,12 +121,12 @@ public final class TopAndRowNumberDecoratorMergedResultTest {
     
     @Test
     public void assertNextWithOffsetBoundOpenedFalse() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false), 
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()),
-                new Pagination(new NumberLiteralRowNumberValueSegment(0, 0, 2, false), new NumberLiteralLimitValueSegment(0, 0, 4), Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false), 
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()),
+                new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, false), new NumberLiteralLimitValueSegment(0, 0, 4), Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         assertTrue(actual.next());
@@ -136,12 +136,12 @@ public final class TopAndRowNumberDecoratorMergedResultTest {
     
     @Test
     public void assertNextWithOffsetBoundOpenedTrue() throws SQLException {
-        OptimizedStatement shardingStatement = new SelectOptimizedStatement(new SelectStatement(), 
-                new GroupBy(Collections.<OrderByItem>emptyList(), 0), new OrderBy(Collections.<OrderByItem>emptyList(), false), 
-                new SelectItems(0, 0, false, Collections.<SelectItem>emptyList()),
-                new Pagination(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), new NumberLiteralLimitValueSegment(0, 0, 4), Collections.emptyList()));
+        SQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(), 
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false), 
+                new SelectItemsContext(0, 0, false, Collections.<SelectItem>emptyList()),
+                new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), new NumberLiteralLimitValueSegment(0, 0, 4), Collections.emptyList()));
         SQLRouteResult routeResult = new SQLRouteResult(
-                shardingStatement, new CommonOptimizedStatement(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
+                selectSQLStatementContext, new CommonSQLStatementContext(new SelectStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
         mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), null, routeResult, queryResults);
         MergedResult actual = mergeEngine.merge();
         assertTrue(actual.next());

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/OptimizedStatementFactory.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/SQLStatementContextFactory.java

@@ -20,10 +20,10 @@ package org.apache.shardingsphere.core.optimize;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.statement.impl.CommonOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.CommonSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.statement.SQLStatement;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.InsertStatement;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.SelectStatement;
@@ -31,31 +31,31 @@ import org.apache.shardingsphere.core.parse.sql.statement.dml.SelectStatement;
 import java.util.List;
 
 /**
- * Optimized statement factory.
+ * SQL statement context factory.
  *
  * @author zhangliang
  * @author maxiaoguang
  * @author panjuan
  */
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class OptimizedStatementFactory {
+public final class SQLStatementContextFactory {
     
     /**
-     * Create optimized statement.
+     * Create SQL statement context.
      *
      * @param tableMetas table meta data
      * @param sql SQL
      * @param parameters SQL parameters
      * @param sqlStatement SQL statement
-     * @return optimized statement
+     * @return SQL statement context
      */
-    public static OptimizedStatement newInstance(final TableMetas tableMetas, final String sql, final List<Object> parameters, final SQLStatement sqlStatement) {
+    public static SQLStatementContext newInstance(final TableMetas tableMetas, final String sql, final List<Object> parameters, final SQLStatement sqlStatement) {
         if (sqlStatement instanceof SelectStatement) {
-            return new SelectOptimizedStatement(tableMetas, sql, parameters, (SelectStatement) sqlStatement);
+            return new SelectSQLStatementContext(tableMetas, sql, parameters, (SelectStatement) sqlStatement);
         }
         if (sqlStatement instanceof InsertStatement) {
-            return new InsertOptimizedStatement(tableMetas, parameters, (InsertStatement) sqlStatement);
+            return new InsertSQLStatementContext(tableMetas, parameters, (InsertStatement) sqlStatement);
         }
-        return new CommonOptimizedStatement(sqlStatement);
+        return new CommonSQLStatementContext(sqlStatement);
     }
 }

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/insert/InsertValue.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/insert/InsertValueContext.java

@@ -32,14 +32,14 @@ import java.util.Collections;
 import java.util.List;
 
 /**
- * Insert value.
+ * Insert value context.
  *
  * @author panjuan
  * @author zhangliang
  */
 @Getter
 @ToString
-public final class InsertValue {
+public final class InsertValueContext {
     
     private final int parametersCount;
     
@@ -47,7 +47,7 @@ public final class InsertValue {
     
     private final List<Object> parameters;
     
-    public InsertValue(final Collection<ExpressionSegment> assignments, final List<Object> parameters, final int parametersOffset) {
+    public InsertValueContext(final Collection<ExpressionSegment> assignments, final List<Object> parameters, final int parametersOffset) {
         parametersCount = calculateParametersCount(assignments);
         valueExpressions = getValueExpressions(assignments);
         this.parameters = getParameters(parameters, parametersOffset);

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/groupby/GroupBy.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/groupby/GroupByContext.java

@@ -24,13 +24,13 @@ import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByIte
 import java.util.Collection;
 
 /**
- * Group by.
+ * Group by context.
  *
  * @author zhangliang
  */
 @RequiredArgsConstructor
 @Getter
-public final class GroupBy {
+public final class GroupByContext {
     
     private final Collection<OrderByItem> items;
     

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/groupby/engine/GroupByEngine.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/groupby/engine/GroupByContextEngine.java

@@ -17,7 +17,7 @@
 
 package org.apache.shardingsphere.core.optimize.segment.select.groupby.engine;
 
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.IndexOrderByItemSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.OrderByItemSegment;
@@ -28,21 +28,21 @@ import java.util.Collections;
 import java.util.LinkedList;
 
 /**
- * Group by engine.
+ * Group by context engine.
  *
  * @author zhangliang
  */
-public final class GroupByEngine {
+public final class GroupByContextEngine {
     
     /**
-     * Create group by.
+     * Create group by context.
      *
      * @param selectStatement select statement
-     * @return group by
+     * @return group by context
      */
-    public GroupBy createGroupBy(final SelectStatement selectStatement) {
+    public GroupByContext createGroupByContext(final SelectStatement selectStatement) {
         if (!selectStatement.getGroupBy().isPresent()) {
-            return new GroupBy(Collections.<OrderByItem>emptyList(), 0);
+            return new GroupByContext(Collections.<OrderByItem>emptyList(), 0);
         }
         Collection<OrderByItem> groupByItems = new LinkedList<>();
         for (OrderByItemSegment each : selectStatement.getGroupBy().get().getGroupByItems()) {
@@ -52,6 +52,6 @@ public final class GroupByEngine {
             }
             groupByItems.add(orderByItem);
         }
-        return new GroupBy(groupByItems, selectStatement.getGroupBy().get().getStopIndex());
+        return new GroupByContext(groupByItems, selectStatement.getGroupBy().get().getStopIndex());
     }
 }

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/item/SelectItems.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/item/SelectItemsContext.java

@@ -20,7 +20,6 @@ package org.apache.shardingsphere.core.optimize.segment.select.item;
 import com.google.common.base.Optional;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
-import lombok.Setter;
 import lombok.ToString;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationDistinctSelectItem;
@@ -35,16 +34,15 @@ import java.util.LinkedList;
 import java.util.List;
 
 /**
- * Select items.
+ * Select items context.
  *
  * @author zhangliang
  * @author sunbufu
  */
 @RequiredArgsConstructor
 @Getter
-@Setter
 @ToString
-public final class SelectItems {
+public final class SelectItemsContext {
     
     private final int startIndex;
     

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/item/engine/SelectItemsEngine.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/item/engine/SelectItemsContextEngine.java

@@ -21,16 +21,16 @@ import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.segment.Table;
-import org.apache.shardingsphere.core.optimize.segment.Tables;
+import org.apache.shardingsphere.core.optimize.segment.table.Table;
+import org.apache.shardingsphere.core.optimize.segment.table.TablesContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.DerivedColumn;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.ShorthandSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.DerivedSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.item.SelectItemSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.item.SelectItemsSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.ColumnOrderByItemSegment;
@@ -43,34 +43,34 @@ import java.util.Collection;
 import java.util.LinkedList;
 
 /**
- * Select items engine.
+ * Select items context engine.
  *
  * @author zhangliang
  * @author sunbufu
  */
 @RequiredArgsConstructor
-public final class SelectItemsEngine {
+public final class SelectItemsContextEngine {
     
     private final TableMetas tableMetas;
     
     private final SelectItemEngine selectItemEngine = new SelectItemEngine();
     
     /**
-     * Create select items.
+     * Create select items context.
      *
      * @param sql SQL
      * @param selectStatement SQL statement
-     * @param groupBy group by
-     * @param orderBy order by
-     * @return select items
+     * @param groupByContext group by context
+     * @param orderByContext order by context
+     * @return select items context
      */
-    public SelectItems createSelectItems(final String sql, final SelectStatement selectStatement, final GroupBy groupBy, final OrderBy orderBy) {
+    public SelectItemsContext createSelectItemsContext(final String sql, final SelectStatement selectStatement, final GroupByContext groupByContext, final OrderByContext orderByContext) {
         SelectItemsSegment selectItemsSegment = selectStatement.getSelectItems();
         Collection<SelectItem> items = getSelectItemList(sql, selectItemsSegment);
-        SelectItems result = new SelectItems(selectItemsSegment.getStartIndex(), selectItemsSegment.getStopIndex(), selectItemsSegment.isDistinctRow(), items);
-        Tables tables = new Tables(selectStatement);
-        result.getItems().addAll(getDerivedGroupByColumns(tables, items, groupBy));
-        result.getItems().addAll(getDerivedOrderByColumns(tables, items, orderBy));
+        SelectItemsContext result = new SelectItemsContext(selectItemsSegment.getStartIndex(), selectItemsSegment.getStopIndex(), selectItemsSegment.isDistinctRow(), items);
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        result.getItems().addAll(getDerivedGroupByColumns(tablesContext, items, groupByContext));
+        result.getItems().addAll(getDerivedOrderByColumns(tablesContext, items, orderByContext));
         return result;
     }
     
@@ -85,33 +85,34 @@ public final class SelectItemsEngine {
         return result;
     }
     
-    private Collection<SelectItem> getDerivedGroupByColumns(final Tables tables, final Collection<SelectItem> selectItems, final GroupBy groupBy) {
-        return getDerivedOrderColumns(tables, selectItems, groupBy.getItems(), DerivedColumn.GROUP_BY_ALIAS);
+    private Collection<SelectItem> getDerivedGroupByColumns(final TablesContext tablesContext, final Collection<SelectItem> selectItems, final GroupByContext groupByContext) {
+        return getDerivedOrderColumns(tablesContext, selectItems, groupByContext.getItems(), DerivedColumn.GROUP_BY_ALIAS);
     }
     
-    private Collection<SelectItem> getDerivedOrderByColumns(final Tables tables, final Collection<SelectItem> selectItems, final OrderBy orderBy) {
-        return getDerivedOrderColumns(tables, selectItems, orderBy.getItems(), DerivedColumn.ORDER_BY_ALIAS);
+    private Collection<SelectItem> getDerivedOrderByColumns(final TablesContext tablesContext, final Collection<SelectItem> selectItems, final OrderByContext orderByContext) {
+        return getDerivedOrderColumns(tablesContext, selectItems, orderByContext.getItems(), DerivedColumn.ORDER_BY_ALIAS);
     }
     
-    private Collection<SelectItem> getDerivedOrderColumns(final Tables tables, final Collection<SelectItem> selectItems, final Collection<OrderByItem> orderItems, final DerivedColumn derivedColumn) {
+    private Collection<SelectItem> getDerivedOrderColumns(final TablesContext tablesContext, 
+                                                          final Collection<SelectItem> selectItems, final Collection<OrderByItem> orderItems, final DerivedColumn derivedColumn) {
         Collection<SelectItem> result = new LinkedList<>();
         int derivedColumnOffset = 0;
         for (OrderByItem each : orderItems) {
-            if (!containsItem(tables, selectItems, each.getSegment())) {
+            if (!containsItem(tablesContext, selectItems, each.getSegment())) {
                 result.add(new DerivedSelectItem(((TextOrderByItemSegment) each.getSegment()).getText(), derivedColumn.getDerivedColumnAlias(derivedColumnOffset++)));
             }
         }
         return result;
     }
     
-    private boolean containsItem(final Tables tables, final Collection<SelectItem> items, final OrderByItemSegment orderByItemSegment) {
+    private boolean containsItem(final TablesContext tablesContext, final Collection<SelectItem> items, final OrderByItemSegment orderByItemSegment) {
         return orderByItemSegment instanceof IndexOrderByItemSegment
-                || containsItemInShorthandItems(tables, items, orderByItemSegment) || containsItemInSelectItems(items, orderByItemSegment);
+                || containsItemInShorthandItems(tablesContext, items, orderByItemSegment) || containsItemInSelectItems(items, orderByItemSegment);
     }
     
-    private boolean containsItemInShorthandItems(final Tables tables, final Collection<SelectItem> items, final OrderByItemSegment orderByItemSegment) {
+    private boolean containsItemInShorthandItems(final TablesContext tablesContext, final Collection<SelectItem> items, final OrderByItemSegment orderByItemSegment) {
         return isUnqualifiedShorthandItem(items)
-                || containsItemWithOwnerInShorthandItems(tables, items, orderByItemSegment) || containsItemWithoutOwnerInShorthandItems(tables, items, orderByItemSegment);
+                || containsItemWithOwnerInShorthandItems(tablesContext, items, orderByItemSegment) || containsItemWithoutOwnerInShorthandItems(tablesContext, items, orderByItemSegment);
     }
     
     private boolean isUnqualifiedShorthandItem(final Collection<SelectItem> items) {
@@ -122,13 +123,13 @@ public final class SelectItemsEngine {
         return item instanceof ShorthandSelectItem && !((ShorthandSelectItem) item).getOwner().isPresent();
     }
     
-    private boolean containsItemWithOwnerInShorthandItems(final Tables tables, final Collection<SelectItem> items, final OrderByItemSegment orderItem) {
+    private boolean containsItemWithOwnerInShorthandItems(final TablesContext tablesContext, final Collection<SelectItem> items, final OrderByItemSegment orderItem) {
         return orderItem instanceof ColumnOrderByItemSegment && ((ColumnOrderByItemSegment) orderItem).getColumn().getOwner().isPresent()
-                && findShorthandItem(tables, items, ((ColumnOrderByItemSegment) orderItem).getColumn().getOwner().get().getTableName()).isPresent();
+                && findShorthandItem(tablesContext, items, ((ColumnOrderByItemSegment) orderItem).getColumn().getOwner().get().getTableName()).isPresent();
     }
     
-    private Optional<ShorthandSelectItem> findShorthandItem(final Tables tables, final Collection<SelectItem> items, final String tableNameOrAlias) {
-        Optional<Table> table = tables.find(tableNameOrAlias);
+    private Optional<ShorthandSelectItem> findShorthandItem(final TablesContext tablesContext, final Collection<SelectItem> items, final String tableNameOrAlias) {
+        Optional<Table> table = tablesContext.find(tableNameOrAlias);
         if (!table.isPresent()) {
             return Optional.absent();
         }
@@ -137,20 +138,20 @@ public final class SelectItemsEngine {
                 continue;
             }
             ShorthandSelectItem shorthandSelectItem = (ShorthandSelectItem) each;
-            if (shorthandSelectItem.getOwner().isPresent() && tables.find(shorthandSelectItem.getOwner().get()).equals(table)) {
+            if (shorthandSelectItem.getOwner().isPresent() && tablesContext.find(shorthandSelectItem.getOwner().get()).equals(table)) {
                 return Optional.of(shorthandSelectItem);
             }
         }
         return Optional.absent();
     }
     
-    private boolean containsItemWithoutOwnerInShorthandItems(final Tables tables, final Collection<SelectItem> items, final OrderByItemSegment orderItem) {
+    private boolean containsItemWithoutOwnerInShorthandItems(final TablesContext tablesContext, final Collection<SelectItem> items, final OrderByItemSegment orderItem) {
         if (!(orderItem instanceof ColumnOrderByItemSegment)) {
             return false;
         }
         if (!((ColumnOrderByItemSegment) orderItem).getColumn().getOwner().isPresent()) {
             for (ShorthandSelectItem each : getQualifiedShorthandItems(items)) {
-                if (isSameSelectItem(tables, each, (ColumnOrderByItemSegment) orderItem)) {
+                if (isSameSelectItem(tablesContext, each, (ColumnOrderByItemSegment) orderItem)) {
                     return true;
                 }
             }
@@ -168,9 +169,9 @@ public final class SelectItemsEngine {
         return result;
     }
     
-    private boolean isSameSelectItem(final Tables tables, final ShorthandSelectItem shorthandSelectItem, final ColumnOrderByItemSegment orderItem) {
+    private boolean isSameSelectItem(final TablesContext tablesContext, final ShorthandSelectItem shorthandSelectItem, final ColumnOrderByItemSegment orderItem) {
         Preconditions.checkState(shorthandSelectItem.getOwner().isPresent());
-        Optional<Table> table = tables.find(shorthandSelectItem.getOwner().get());
+        Optional<Table> table = tablesContext.find(shorthandSelectItem.getOwner().get());
         return table.isPresent() && tableMetas.containsColumn(table.get().getName(), orderItem.getColumn().getName());
     }
     

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/orderby/OrderBy.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/orderby/OrderByContext.java

@@ -23,13 +23,13 @@ import lombok.RequiredArgsConstructor;
 import java.util.Collection;
 
 /**
- * Order by.
+ * Order by context.
  *
  * @author zhangliang
  */
 @RequiredArgsConstructor
 @Getter
-public final class OrderBy {
+public final class OrderByContext {
     
     private final Collection<OrderByItem> items;
     

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/orderby/engine/OrderByEngine.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/orderby/engine/OrderByContextEngine.java

@@ -17,8 +17,8 @@
 
 package org.apache.shardingsphere.core.optimize.segment.select.orderby.engine;
 
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.IndexOrderByItemSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.OrderByItemSegment;
@@ -28,22 +28,22 @@ import java.util.LinkedList;
 import java.util.List;
 
 /**
- * Order by engine.
+ * Order by context engine.
  *
  * @author zhangliang
  */
-public final class OrderByEngine {
+public final class OrderByContextEngine {
     
     /**
-     * Create order by.
+     * Create order by context.
      * 
      * @param selectStatement select statement
-     * @param groupBy group by
-     * @return order by
+     * @param groupByContext group by context
+     * @return order by context
      */
-    public OrderBy createOrderBy(final SelectStatement selectStatement, final GroupBy groupBy) {
+    public OrderByContext createOrderBy(final SelectStatement selectStatement, final GroupByContext groupByContext) {
         if (!selectStatement.getOrderBy().isPresent() || selectStatement.getOrderBy().get().getOrderByItems().isEmpty()) {
-            return new OrderBy(groupBy.getItems(), !groupBy.getItems().isEmpty());
+            return new OrderByContext(groupByContext.getItems(), !groupByContext.getItems().isEmpty());
         }
         List<OrderByItem> orderByItems = new LinkedList<>();
         for (OrderByItemSegment each : selectStatement.getOrderBy().get().getOrderByItems()) {
@@ -53,6 +53,6 @@ public final class OrderByEngine {
             }
             orderByItems.add(orderByItem);
         }
-        return new OrderBy(orderByItems, false);
+        return new OrderByContext(orderByItems, false);
     }
 }

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/Pagination.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/PaginationContext.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.core.optimize.segment.select.pagination;
 
 import com.google.common.base.Optional;
 import lombok.Getter;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.NumberLiteralPaginationValueSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.PaginationValueSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.ParameterMarkerPaginationValueSegment;
@@ -28,13 +28,13 @@ import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.limit.Lim
 import java.util.List;
 
 /**
- * Pagination.
+ * Pagination context.
  *
  * @author zhangliang
  * @author caohao
  * @author zhangyonglun
  */
-public final class Pagination {
+public final class PaginationContext {
     
     @Getter
     private final boolean hasPagination;
@@ -47,7 +47,7 @@ public final class Pagination {
     
     private final Long actualRowCount;
     
-    public Pagination(final PaginationValueSegment offsetSegment, final PaginationValueSegment rowCountSegment, final List<Object> parameters) {
+    public PaginationContext(final PaginationValueSegment offsetSegment, final PaginationValueSegment rowCountSegment, final List<Object> parameters) {
         hasPagination = null != offsetSegment || null != rowCountSegment;
         this.offsetSegment = offsetSegment;
         this.rowCountSegment = rowCountSegment;
@@ -140,15 +140,15 @@ public final class Pagination {
      * @param shardingStatement sharding optimized statement
      * @return revised row count
      */
-    public long getRevisedRowCount(final SelectOptimizedStatement shardingStatement) {
+    public long getRevisedRowCount(final SelectSQLStatementContext shardingStatement) {
         if (isMaxRowCount(shardingStatement)) {
             return Integer.MAX_VALUE;
         }
         return rowCountSegment instanceof LimitValueSegment ? actualOffset + actualRowCount : actualRowCount;
     }
     
-    private boolean isMaxRowCount(final SelectOptimizedStatement shardingStatement) {
-        return (!shardingStatement.getGroupBy().getItems().isEmpty()
-                || !shardingStatement.getSelectItems().getAggregationSelectItems().isEmpty()) && !shardingStatement.isSameGroupByAndOrderByItems();
+    private boolean isMaxRowCount(final SelectSQLStatementContext shardingStatement) {
+        return (!shardingStatement.getGroupByContext().getItems().isEmpty()
+                || !shardingStatement.getSelectItemsContext().getAggregationSelectItems().isEmpty()) && !shardingStatement.isSameGroupByAndOrderByItems();
     }
 }

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/engine/LimitPaginationEngine.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/engine/LimitPaginationContextEngine.java

@@ -17,26 +17,26 @@
 
 package org.apache.shardingsphere.core.optimize.segment.select.pagination.engine;
 
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.limit.LimitSegment;
 
 import java.util.List;
 
 /**
- * Pagination engine for limit.
+ * Pagination context engine for limit.
  *
  * @author zhangliang
  */
-public final class LimitPaginationEngine {
+public final class LimitPaginationContextEngine {
     
     /**
-     * Create pagination.
+     * Create pagination context.
      * 
      * @param limitSegment limit segment
      * @param parameters SQL parameters
-     * @return pagination
+     * @return pagination context
      */
-    public Pagination createPagination(final LimitSegment limitSegment, final List<Object> parameters) {
-        return new Pagination(limitSegment.getOffset().orNull(), limitSegment.getRowCount().orNull(), parameters);
+    public PaginationContext createPaginationContext(final LimitSegment limitSegment, final List<Object> parameters) {
+        return new PaginationContext(limitSegment.getOffset().orNull(), limitSegment.getRowCount().orNull(), parameters);
     }
 }

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/engine/PaginationEngine.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/engine/PaginationContextEngine.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.optimize.segment.select.pagination.engine;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.limit.LimitSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.top.TopSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.predicate.AndPredicate;
@@ -30,33 +30,34 @@ import java.util.Collections;
 import java.util.List;
 
 /**
- * Pagination engine.
+ * Pagination context engine.
  *
  * @author zhangliang
  */
-public final class PaginationEngine {
+public final class PaginationContextEngine {
     
     /**
-     * Create pagination.
+     * Create pagination context.
      * 
      * @param selectStatement SQL statement
      * @param selectItems select items
      * @param parameters SQL parameters
-     * @return pagination
+     * @return pagination context
      */
-    public Pagination createPagination(final SelectStatement selectStatement, final SelectItems selectItems, final List<Object> parameters) {
+    public PaginationContext createPaginationContext(final SelectStatement selectStatement, final SelectItemsContext selectItems, final List<Object> parameters) {
         Optional<LimitSegment> limitSegment = selectStatement.findSQLSegment(LimitSegment.class);
         if (limitSegment.isPresent()) {
-            return new LimitPaginationEngine().createPagination(limitSegment.get(), parameters);
+            return new LimitPaginationContextEngine().createPaginationContext(limitSegment.get(), parameters);
         }
         Optional<TopSegment> topSegment = selectStatement.findSQLSegment(TopSegment.class);
         Optional<WhereSegment> whereSegment = selectStatement.findSQLSegment(WhereSegment.class);
         if (topSegment.isPresent()) {
-            return new TopPaginationEngine().createPagination(topSegment.get(), whereSegment.isPresent() ? whereSegment.get().getAndPredicates() : Collections.<AndPredicate>emptyList(), parameters);
+            return new TopPaginationContextEngine().createPaginationContext(
+                    topSegment.get(), whereSegment.isPresent() ? whereSegment.get().getAndPredicates() : Collections.<AndPredicate>emptyList(), parameters);
         }
         if (whereSegment.isPresent()) {
-            return new RowNumberPaginationEngine().createPagination(whereSegment.get().getAndPredicates(), selectItems, parameters);
+            return new RowNumberPaginationContextEngine().createPaginationContext(whereSegment.get().getAndPredicates(), selectItems, parameters);
         }
-        return new Pagination(null, null, parameters);
+        return new PaginationContext(null, null, parameters);
     }
 }

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/engine/RowNumberPaginationEngine.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/engine/RowNumberPaginationContextEngine.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.optimize.segment.select.pagination.engine;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
@@ -36,11 +36,11 @@ import java.util.LinkedList;
 import java.util.List;
 
 /**
- * Pagination engine for row number.
+ * Pagination context engine for row number.
  *
  * @author zhangliang
  */
-public final class RowNumberPaginationEngine {
+public final class RowNumberPaginationContextEngine {
     
     // TODO recognize database type, only oracle and sqlserver can use row number
     private static final Collection<String> ROW_NUMBER_IDENTIFIERS = new HashSet<>();
@@ -51,20 +51,20 @@ public final class RowNumberPaginationEngine {
     }
     
     /**
-     * Create pagination.
+     * Create pagination context.
      * 
      * @param andPredicates and predicates
      * @param selectItems select items
      * @param parameters SQL parameters
-     * @return pagination
+     * @return pagination context
      */
-    public Pagination createPagination(final Collection<AndPredicate> andPredicates, final SelectItems selectItems, final List<Object> parameters) {
+    public PaginationContext createPaginationContext(final Collection<AndPredicate> andPredicates, final SelectItemsContext selectItems, final List<Object> parameters) {
         Optional<String> rowNumberAlias = isRowNumberAlias(selectItems);
         if (!rowNumberAlias.isPresent()) {
-            return new Pagination(null, null, parameters);
+            return new PaginationContext(null, null, parameters);
         }
         Collection<PredicateSegment> rowNumberPredicates = getRowNumberPredicates(andPredicates, rowNumberAlias.get());
-        return rowNumberPredicates.isEmpty() ? new Pagination(null, null, parameters) : createPaginationWithRowNumber(rowNumberPredicates, parameters);
+        return rowNumberPredicates.isEmpty() ? new PaginationContext(null, null, parameters) : createPaginationWithRowNumber(rowNumberPredicates, parameters);
     }
     
     private Collection<PredicateSegment> getRowNumberPredicates(final Collection<AndPredicate> andPredicates, final String rowNumberAlias) {
@@ -79,7 +79,7 @@ public final class RowNumberPaginationEngine {
         return result;
     }
     
-    private Optional<String> isRowNumberAlias(final SelectItems selectItems) {
+    private Optional<String> isRowNumberAlias(final SelectItemsContext selectItems) {
         for (String each : ROW_NUMBER_IDENTIFIERS) {
             Optional<String> result = selectItems.findAlias(each);
             if (result.isPresent()) {
@@ -101,7 +101,7 @@ public final class RowNumberPaginationEngine {
         return false;
     }
     
-    private Pagination createPaginationWithRowNumber(final Collection<PredicateSegment> rowNumberPredicates, final List<Object> parameters) {
+    private PaginationContext createPaginationWithRowNumber(final Collection<PredicateSegment> rowNumberPredicates, final List<Object> parameters) {
         RowNumberValueSegment offset = null;
         RowNumberValueSegment rowCount = null;
         for (PredicateSegment each : rowNumberPredicates) {
@@ -123,7 +123,7 @@ public final class RowNumberPaginationEngine {
                     break;
             }
         }
-        return new Pagination(offset, rowCount, parameters);
+        return new PaginationContext(offset, rowCount, parameters);
     }
     
     private RowNumberValueSegment createRowNumberValueSegment(final ExpressionSegment expression, final boolean boundOpened) {

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/engine/TopPaginationEngine.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/engine/TopPaginationContextEngine.java

@@ -18,7 +18,7 @@
 package org.apache.shardingsphere.core.optimize.segment.select.pagination.engine;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
@@ -35,25 +35,25 @@ import java.util.Collection;
 import java.util.List;
 
 /**
- * Pagination engine for top.
+ * Pagination context engine for top.
  *
  * @author zhangliang
  */
-public final class TopPaginationEngine {
+public final class TopPaginationContextEngine {
     
     /**
-     * Create pagination.
+     * Create pagination context.
      * 
      * @param topSegment top segment
      * @param andPredicates and predicates
      * @param parameters SQL parameters
-     * @return pagination
+     * @return pagination context
      */
-    public Pagination createPagination(final TopSegment topSegment, final Collection<AndPredicate> andPredicates, final List<Object> parameters) {
+    public PaginationContext createPaginationContext(final TopSegment topSegment, final Collection<AndPredicate> andPredicates, final List<Object> parameters) {
         Optional<PredicateSegment> rowNumberPredicate = getRowNumberPredicate(andPredicates, topSegment.getRowNumberAlias());
         Optional<PaginationValueSegment> offset = rowNumberPredicate.isPresent() ? createOffsetWithRowNumber(rowNumberPredicate.get()) : Optional.<PaginationValueSegment>absent();
         PaginationValueSegment rowCount = topSegment.getTop();
-        return new Pagination(offset.orNull(), rowCount, parameters);
+        return new PaginationContext(offset.orNull(), rowCount, parameters);
     }
     
     private Optional<PredicateSegment> getRowNumberPredicate(final Collection<AndPredicate> andPredicates, final String rowNumberAlias) {

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/Table.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/table/Table.java

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.optimize.segment;
+package org.apache.shardingsphere.core.optimize.segment.table;
 
 import com.google.common.base.Optional;
 import lombok.EqualsAndHashCode;

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/Tables.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/segment/table/TablesContext.java

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.optimize.segment;
+package org.apache.shardingsphere.core.optimize.segment.table;
 
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
@@ -35,18 +35,18 @@ import java.util.LinkedHashSet;
 import java.util.TreeSet;
 
 /**
- * Tables.
+ * Tables context.
  * 
  * @author zhangliang
  */
 @ToString
-public final class Tables {
+public final class TablesContext {
     
     private final Collection<Table> tables = new ArrayList<>();
     
     private String schema;
     
-    public Tables(final SQLStatement sqlStatement) {
+    public TablesContext(final SQLStatement sqlStatement) {
         Collection<String> aliases = new HashSet<>();
         for (TableAvailable each : sqlStatement.findSQLSegments(TableAvailable.class)) {
             Optional<String> alias = getAlias(each);

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/statement/OptimizedStatement.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/statement/SQLStatementContext.java

@@ -17,15 +17,15 @@
 
 package org.apache.shardingsphere.core.optimize.statement;
 
-import org.apache.shardingsphere.core.optimize.segment.Tables;
+import org.apache.shardingsphere.core.optimize.segment.table.TablesContext;
 import org.apache.shardingsphere.core.parse.sql.statement.SQLStatement;
 
 /**
- * Optimized statement.
+ * SQL statement context.
  *
  * @author zhangliang
  */
-public interface OptimizedStatement {
+public interface SQLStatementContext {
     
     /**
      * Get SQL statement.
@@ -35,9 +35,9 @@ public interface OptimizedStatement {
     SQLStatement getSqlStatement();
     
     /**
-     * Get tables.
+     * Get tables context.
      *
-     * @return tables
+     * @return tables context
      */
-    Tables getTables();
+    TablesContext getTablesContext();
 }

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/statement/impl/CommonOptimizedStatement.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/statement/impl/CommonSQLStatementContext.java

@@ -19,25 +19,25 @@ package org.apache.shardingsphere.core.optimize.statement.impl;
 
 import lombok.Getter;
 import lombok.ToString;
-import org.apache.shardingsphere.core.optimize.segment.Tables;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.table.TablesContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.statement.SQLStatement;
 
 /**
- * Common optimized statement.
+ * Common SQL statement context.
  *
  * @author zhangliang
  */
 @Getter
 @ToString
-public class CommonOptimizedStatement implements OptimizedStatement {
+public class CommonSQLStatementContext implements SQLStatementContext {
     
     private final SQLStatement sqlStatement;
     
-    private final Tables tables;
+    private final TablesContext tablesContext;
     
-    public CommonOptimizedStatement(final SQLStatement sqlStatement) {
+    public CommonSQLStatementContext(final SQLStatement sqlStatement) {
         this.sqlStatement = sqlStatement;
-        tables = new Tables(sqlStatement);
+        tablesContext = new TablesContext(sqlStatement);
     }
 }

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/statement/impl/InsertOptimizedStatement.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/statement/impl/InsertSQLStatementContext.java

@@ -20,7 +20,7 @@ package org.apache.shardingsphere.core.optimize.statement.impl;
 import lombok.Getter;
 import lombok.ToString;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.segment.insert.InsertValue;
+import org.apache.shardingsphere.core.optimize.segment.insert.InsertValueContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.InsertStatement;
 
@@ -29,31 +29,31 @@ import java.util.LinkedList;
 import java.util.List;
 
 /**
- * Insert optimized statement.
+ * Insert SQL statement context.
  *
  * @author zhangliang
  */
 @Getter
 @ToString(callSuper = true)
-public final class InsertOptimizedStatement extends CommonOptimizedStatement {
+public final class InsertSQLStatementContext extends CommonSQLStatementContext {
     
     private final List<String> columnNames;
     
-    private final List<InsertValue> insertValues;
+    private final List<InsertValueContext> insertValueContexts;
     
-    public InsertOptimizedStatement(final TableMetas tableMetas, final List<Object> parameters, final InsertStatement sqlStatement) {
+    public InsertSQLStatementContext(final TableMetas tableMetas, final List<Object> parameters, final InsertStatement sqlStatement) {
         super(sqlStatement);
-        columnNames = sqlStatement.useDefaultColumns() ? tableMetas.getAllColumnNames(getTables().getSingleTableName()) : sqlStatement.getColumnNames();
-        insertValues = getInsertValues(parameters);
+        columnNames = sqlStatement.useDefaultColumns() ? tableMetas.getAllColumnNames(this.getTablesContext().getSingleTableName()) : sqlStatement.getColumnNames();
+        insertValueContexts = getInsertValueContexts(parameters);
     }
     
-    private List<InsertValue> getInsertValues(final List<Object> parameters) {
-        List<InsertValue> result = new LinkedList<>();
+    private List<InsertValueContext> getInsertValueContexts(final List<Object> parameters) {
+        List<InsertValueContext> result = new LinkedList<>();
         int parametersOffset = 0;
         for (Collection<ExpressionSegment> each : ((InsertStatement) getSqlStatement()).getAllValueExpressions()) {
-            InsertValue insertValue = new InsertValue(each, parameters, parametersOffset);
-            result.add(insertValue);
-            parametersOffset += insertValue.getParametersCount();
+            InsertValueContext insertValueContext = new InsertValueContext(each, parameters, parametersOffset);
+            result.add(insertValueContext);
+            parametersOffset += insertValueContext.getParametersCount();
         }
         return result;
     }

sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/statement/impl/SelectOptimizedStatement.java → sharding-core/sharding-core-optimize/src/main/java/org/apache/shardingsphere/core/optimize/statement/impl/SelectSQLStatementContext.java

@@ -22,17 +22,17 @@ import com.google.common.base.Preconditions;
 import lombok.Getter;
 import lombok.ToString;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.engine.GroupByEngine;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.engine.GroupByContextEngine;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.item.engine.SelectItemsEngine;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.item.engine.SelectItemsContextEngine;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.engine.OrderByEngine;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.engine.PaginationEngine;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.engine.OrderByContextEngine;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.engine.PaginationContextEngine;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.ColumnOrderByItemSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.ExpressionOrderByItemSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.IndexOrderByItemSegment;
@@ -46,40 +46,41 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * Select optimized statement.
+ * Select SQL statement context.
  *
  * @author zhangliang
  */
 @Getter
 @ToString(callSuper = true)
-public final class SelectOptimizedStatement extends CommonOptimizedStatement {
+public final class SelectSQLStatementContext extends CommonSQLStatementContext {
     
-    private final GroupBy groupBy;
+    private final GroupByContext groupByContext;
     
-    private final OrderBy orderBy;
+    private final OrderByContext orderByContext;
     
-    private final SelectItems selectItems;
+    private final SelectItemsContext selectItemsContext;
     
-    private final Pagination pagination;
+    private final PaginationContext paginationContext;
     
     private final boolean containsSubquery;
     
     // TODO to be remove, for test case only
-    public SelectOptimizedStatement(final SelectStatement sqlStatement, final GroupBy groupBy, final OrderBy orderBy, final SelectItems selectItems, final Pagination pagination) {
+    public SelectSQLStatementContext(final SelectStatement sqlStatement,
+                                     final GroupByContext groupByContext, final OrderByContext orderByContext, final SelectItemsContext selectItemsContext, final PaginationContext paginationContext) {
         super(sqlStatement);
-        this.groupBy = groupBy;
-        this.orderBy = orderBy;
-        this.selectItems = selectItems;
-        this.pagination = pagination;
+        this.groupByContext = groupByContext;
+        this.orderByContext = orderByContext;
+        this.selectItemsContext = selectItemsContext;
+        this.paginationContext = paginationContext;
         containsSubquery = containsSubquery();
     }
     
-    public SelectOptimizedStatement(final TableMetas tableMetas, final String sql, final List<Object> parameters, final SelectStatement sqlStatement) {
+    public SelectSQLStatementContext(final TableMetas tableMetas, final String sql, final List<Object> parameters, final SelectStatement sqlStatement) {
         super(sqlStatement);
-        this.groupBy = new GroupByEngine().createGroupBy(sqlStatement);
-        this.orderBy = new OrderByEngine().createOrderBy(sqlStatement, groupBy);
-        this.selectItems = new SelectItemsEngine(tableMetas).createSelectItems(sql, sqlStatement, groupBy, orderBy);
-        this.pagination = new PaginationEngine().createPagination(sqlStatement, selectItems, parameters);
+        groupByContext = new GroupByContextEngine().createGroupByContext(sqlStatement);
+        orderByContext = new OrderByContextEngine().createOrderBy(sqlStatement, groupByContext);
+        selectItemsContext = new SelectItemsContextEngine(tableMetas).createSelectItemsContext(sql, sqlStatement, groupByContext, orderByContext);
+        paginationContext = new PaginationContextEngine().createPaginationContext(sqlStatement, selectItemsContext, parameters);
         containsSubquery = containsSubquery();
     }
     
@@ -100,12 +101,12 @@ public final class SelectOptimizedStatement extends CommonOptimizedStatement {
      */
     public void setIndexForItems(final Map<String, Integer> columnLabelIndexMap) {
         setIndexForAggregationItem(columnLabelIndexMap);
-        setIndexForOrderItem(columnLabelIndexMap, orderBy.getItems());
-        setIndexForOrderItem(columnLabelIndexMap, groupBy.getItems());
+        setIndexForOrderItem(columnLabelIndexMap, orderByContext.getItems());
+        setIndexForOrderItem(columnLabelIndexMap, groupByContext.getItems());
     }
     
     private void setIndexForAggregationItem(final Map<String, Integer> columnLabelIndexMap) {
-        for (AggregationSelectItem each : selectItems.getAggregationSelectItems()) {
+        for (AggregationSelectItem each : selectItemsContext.getAggregationSelectItems()) {
             Preconditions.checkState(columnLabelIndexMap.containsKey(each.getColumnLabel()), "Can't find index: %s, please add alias for aggregate selections", each);
             each.setIndex(columnLabelIndexMap.get(each.getColumnLabel()));
             for (AggregationSelectItem derived : each.getDerivedAggregationItems()) {
@@ -122,7 +123,7 @@ public final class SelectOptimizedStatement extends CommonOptimizedStatement {
                 continue;
             }
             if (each.getSegment() instanceof ColumnOrderByItemSegment && ((ColumnOrderByItemSegment) each.getSegment()).getColumn().getOwner().isPresent()) {
-                Optional<Integer> itemIndex = selectItems.findItemIndex(((ColumnOrderByItemSegment) each.getSegment()).getText());
+                Optional<Integer> itemIndex = selectItemsContext.findItemIndex(((ColumnOrderByItemSegment) each.getSegment()).getText());
                 if (itemIndex.isPresent()) {
                     each.setIndex(itemIndex.get());
                     continue;
@@ -138,11 +139,11 @@ public final class SelectOptimizedStatement extends CommonOptimizedStatement {
     }
     
     private Optional<String> getAlias(final String name) {
-        if (selectItems.isUnqualifiedShorthandItem()) {
+        if (selectItemsContext.isUnqualifiedShorthandItem()) {
             return Optional.absent();
         }
         String rawName = SQLUtil.getExactlyValue(name);
-        for (SelectItem each : selectItems.getItems()) {
+        for (SelectItem each : selectItemsContext.getItems()) {
             if (SQLUtil.getExactlyExpression(rawName).equalsIgnoreCase(SQLUtil.getExactlyExpression(SQLUtil.getExactlyValue(each.getExpression())))) {
                 return each.getAlias();
             }
@@ -165,7 +166,7 @@ public final class SelectOptimizedStatement extends CommonOptimizedStatement {
      * @return column labels
      */
     public List<String> getColumnLabels(final TableMetas tableMetas) {
-        return selectItems.getColumnLabels(tableMetas, ((SelectStatement) getSqlStatement()).getTables());
+        return selectItemsContext.getColumnLabels(tableMetas, ((SelectStatement) getSqlStatement()).getTables());
     }
     
     /**
@@ -174,6 +175,6 @@ public final class SelectOptimizedStatement extends CommonOptimizedStatement {
      * @return group by and order by sequence is same or not
      */
     public boolean isSameGroupByAndOrderByItems() {
-        return !groupBy.getItems().isEmpty() && groupBy.getItems().equals(orderBy.getItems());
+        return !groupByContext.getItems().isEmpty() && groupByContext.getItems().equals(orderByContext.getItems());
     }
 }

sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/segment/select/item/SelectItemsTest.java → sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/segment/select/item/SelectItemsContextTest.java

@@ -21,8 +21,6 @@ import com.google.common.base.Optional;
 import org.apache.shardingsphere.core.metadata.column.ColumnMetaData;
 import org.apache.shardingsphere.core.metadata.table.TableMetaData;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationDistinctSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.ColumnSelectItem;
@@ -45,51 +43,51 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-public final class SelectItemsTest {
+public final class SelectItemsContextTest {
     
     @Test
     public void assertUnqualifiedShorthandItemWithEmptyItems() {
-        SelectItems selectItems = new SelectItems(0, 0, true, Collections.<SelectItem>emptySet());
-        assertFalse(selectItems.isUnqualifiedShorthandItem());
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, true, Collections.<SelectItem>emptySet());
+        assertFalse(selectItemsContext.isUnqualifiedShorthandItem());
     }
     
     @Test
     public void assertUnqualifiedShorthandItemWithWrongSelectItem() {
-        SelectItems selectItems = new SelectItems(0, 0, true, Collections.singleton((SelectItem) getColumnSelectItem()));
-        assertFalse(selectItems.isUnqualifiedShorthandItem());
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, true, Collections.singleton((SelectItem) getColumnSelectItem()));
+        assertFalse(selectItemsContext.isUnqualifiedShorthandItem());
     }
     
     @Test
     public void assertUnqualifiedShorthandItemWithWrongShortSelectItem() {
-        SelectItems selectItems = new SelectItems(0, 0, true, Collections.singleton((SelectItem) getShorthandSelectItem()));
-        assertFalse(selectItems.isUnqualifiedShorthandItem());
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, true, Collections.singleton((SelectItem) getShorthandSelectItem()));
+        assertFalse(selectItemsContext.isUnqualifiedShorthandItem());
     }
     
     @Test
     public void assertUnqualifiedShorthandItem() {
         SelectItem selectItem = new ShorthandSelectItem(null);
-        SelectItems selectItems = new SelectItems(0, 0, true, Collections.singleton(selectItem));
-        assertTrue(selectItems.isUnqualifiedShorthandItem());
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, true, Collections.singleton(selectItem));
+        assertTrue(selectItemsContext.isUnqualifiedShorthandItem());
     }
     
     @Test
     public void assertFindAliasWithOutAlias() {
-        SelectItems selectItems = new SelectItems(0, 0, true, Collections.<SelectItem>emptyList());
-        assertFalse(selectItems.findAlias("").isPresent());
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, true, Collections.<SelectItem>emptyList());
+        assertFalse(selectItemsContext.findAlias("").isPresent());
     }
     
     @Test
     public void assertFindAlias() {
         SelectItem selectItem = getColumnSelectItemWithAlias();
-        SelectItems selectItems = new SelectItems(0, 0, true, Collections.singleton(selectItem));
-        assertTrue(selectItems.findAlias(selectItem.getExpression()).isPresent());
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, true, Collections.singleton(selectItem));
+        assertTrue(selectItemsContext.findAlias(selectItem.getExpression()).isPresent());
     }
     
     @Test
     public void assertFindItemIndex() {
         SelectItem selectItem = getColumnSelectItem();
-        SelectItems selectItems = new SelectItems(0, 0, true, Collections.singleton(selectItem));
-        Optional<Integer> actual = selectItems.findItemIndex(selectItem.getExpression());
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, true, Collections.singleton(selectItem));
+        Optional<Integer> actual = selectItemsContext.findItemIndex(selectItem.getExpression());
         assertTrue(actual.isPresent());
         assertThat(actual.get(), is(1));
     }
@@ -97,16 +95,15 @@ public final class SelectItemsTest {
     @Test
     public void assertFindItemIndexFailure() {
         SelectItem selectItem = getColumnSelectItem();
-        SelectItems selectItems = new SelectItems(0, 0, true, Collections.singleton(selectItem));
-        Optional<Integer> actual = selectItems.findItemIndex("");
+        SelectItemsContext selectItemsContext = new SelectItemsContext(0, 0, true, Collections.singleton(selectItem));
+        Optional<Integer> actual = selectItemsContext.findItemIndex("");
         assertFalse(actual.isPresent());
     }
     
     @Test
     public void assertGetAggregationSelectItems() {
         SelectItem aggregationSelectItem = getAggregationSelectItem();
-        List<AggregationSelectItem> items = new SelectItems(0, 0, true, 
-                Arrays.asList(aggregationSelectItem, getColumnSelectItem())).getAggregationSelectItems();
+        List<AggregationSelectItem> items = new SelectItemsContext(0, 0, true, Arrays.asList(aggregationSelectItem, getColumnSelectItem())).getAggregationSelectItems();
         assertTrue(items.contains(aggregationSelectItem));
         assertEquals(items.size(), 1);
     }
@@ -114,7 +111,7 @@ public final class SelectItemsTest {
     @Test
     public void assertGetAggregationDistinctSelectItems() {
         SelectItem aggregationDistinctSelectItem = getAggregationDistinctSelectItem();
-        List<AggregationDistinctSelectItem> items = new SelectItems(0, 0, true, Arrays.asList(aggregationDistinctSelectItem, getColumnSelectItem())).getAggregationDistinctSelectItems();
+        List<AggregationDistinctSelectItem> items = new SelectItemsContext(0, 0, true, Arrays.asList(aggregationDistinctSelectItem, getColumnSelectItem())).getAggregationDistinctSelectItems();
         assertTrue(items.contains(aggregationDistinctSelectItem));
         assertEquals(items.size(), 1);
     }
@@ -122,70 +119,72 @@ public final class SelectItemsTest {
     @Test
     public void assertGetColumnLabelWithShorthandSelectItem() {
         SelectItem selectItem = getShorthandSelectItem();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.singletonList(new TableSegment(0, 0, "table")));
+        List<String> columnLabels = new SelectItemsContext(
+                0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.singletonList(new TableSegment(0, 0, "table")));
         assertEquals(columnLabels, Arrays.asList("id", "name"));
     }
     
     @Test
     public void assertGetColumnLabelWithShorthandSelectItem2() {
         SelectItem selectItem = getShorthandSelectItemWithOutOwner();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.singletonList(new TableSegment(0, 0, "table")));
+        List<String> columnLabels = new SelectItemsContext(
+                0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.singletonList(new TableSegment(0, 0, "table")));
         assertEquals(columnLabels, Arrays.asList("id", "name"));
     }
     
     @Test
     public void assertGetColumnLabelsWithCommonSelectItem() {
         SelectItem selectItem = getColumnSelectItem();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
+        List<String> columnLabels = new SelectItemsContext(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
         assertTrue(columnLabels.contains(selectItem.getColumnLabel()));
     }
     
     @Test
     public void assertGetColumnLabelsWithCommonSelectItemAlias() {
         SelectItem selectItem = getColumnSelectItemWithAlias();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
+        List<String> columnLabels = new SelectItemsContext(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
         assertTrue(columnLabels.contains(selectItem.getAlias().or("")));
     }
     
     @Test
     public void assertGetColumnLabelsWithExpressionSelectItem() {
         SelectItem selectItem = getExpressionSelectItem();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
+        List<String> columnLabels = new SelectItemsContext(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
         assertTrue(columnLabels.contains(selectItem.getColumnLabel()));
     }
     
     @Test
     public void assertGetColumnLabelsWithExpressionSelectItemAlias() {
         SelectItem selectItem = getExpressionSelectItemWithAlias();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
+        List<String> columnLabels = new SelectItemsContext(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
         assertTrue(columnLabels.contains(selectItem.getAlias().or("")));
     }
     
     @Test
     public void assertGetColumnLabelsWithDerivedSelectItem() {
         SelectItem selectItem = getDerivedSelectItem();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
+        List<String> columnLabels = new SelectItemsContext(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
         assertTrue(columnLabels.contains(selectItem.getColumnLabel()));
     }
     
     @Test
     public void assertGetColumnLabelsWithDerivedSelectItemAlias() {
         SelectItem selectItem = getDerivedSelectItemWithAlias();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
+        List<String> columnLabels = new SelectItemsContext(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
         assertTrue(columnLabels.contains(selectItem.getAlias().or("")));
     }
     
     @Test
     public void assertGetColumnLabelsWithAggregationSelectItem() {
         SelectItem selectItem = getAggregationSelectItem();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
+        List<String> columnLabels = new SelectItemsContext(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
         assertTrue(columnLabels.contains(selectItem.getColumnLabel()));
     }
     
     @Test
     public void assertGetColumnLabelsWithAggregationDistinctSelectItem() {
         SelectItem selectItem = getAggregationDistinctSelectItem();
-        List<String> columnLabels = new SelectItems(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
+        List<String> columnLabels = new SelectItemsContext(0, 0, true, Collections.singletonList(selectItem)).getColumnLabels(createTableMetas(), Collections.<TableSegment>emptyList());
         assertTrue(columnLabels.contains(selectItem.getColumnLabel()));
     }
     

sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/PaginationTest.java → sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/segment/select/pagination/PaginationContextTest.java

@@ -18,17 +18,14 @@
 package org.apache.shardingsphere.core.optimize.segment.select.pagination;
 
 import com.google.common.collect.Lists;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
-import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationSelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.PaginationValueSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.limit.NumberLiteralLimitValueSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.limit.ParameterMarkerLimitValueSegment;
 import org.junit.Test;
-import org.mockito.Mockito;
 
 import java.util.Collections;
 import java.util.List;
@@ -37,59 +34,59 @@ import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-public class PaginationTest {
+public final class PaginationContextTest {
     
     @Test
     public void assertSegmentWithNullOffsetSegment() {
         PaginationValueSegment rowCountSegment = getRowCountSegment();
-        Pagination pagination = new Pagination(null, rowCountSegment, getParameters());
-        assertTrue(pagination.isHasPagination());
-        assertNull(pagination.getOffsetSegment().orNull());
-        assertThat(pagination.getRowCountSegment().orNull(), is(rowCountSegment));
+        PaginationContext paginationContext = new PaginationContext(null, rowCountSegment, getParameters());
+        assertTrue(paginationContext.isHasPagination());
+        assertNull(paginationContext.getOffsetSegment().orNull());
+        assertThat(paginationContext.getRowCountSegment().orNull(), is(rowCountSegment));
     }
     
     @Test
     public void assertGetSegmentWithRowCountSegment() {
         PaginationValueSegment offsetSegment = getOffsetSegment();
-        Pagination pagination = new Pagination(offsetSegment, null, getParameters());
-        assertTrue(pagination.isHasPagination());
-        assertThat(pagination.getOffsetSegment().orNull(), is(offsetSegment));
-        assertNull(pagination.getRowCountSegment().orNull());
+        PaginationContext paginationContext = new PaginationContext(offsetSegment, null, getParameters());
+        assertTrue(paginationContext.isHasPagination());
+        assertThat(paginationContext.getOffsetSegment().orNull(), is(offsetSegment));
+        assertNull(paginationContext.getRowCountSegment().orNull());
     }
     
     @Test
     public void assertGetActualOffset() {
-        assertThat(new Pagination(getOffsetSegment(), getRowCountSegment(), getParameters()).getActualOffset(), is(30L));
+        assertThat(new PaginationContext(getOffsetSegment(), getRowCountSegment(), getParameters()).getActualOffset(), is(30L));
     }
     
     @Test
     public void assertGetActualOffsetWithNumberLiteralPaginationValueSegment() {
-        assertThat(new Pagination(getOffsetSegmentWithNumberLiteralPaginationValueSegment(), getRowCountSegmentWithNumberLiteralPaginationValueSegment(), getParameters()).getActualOffset(), is(30L));
+        assertThat(new PaginationContext(getOffsetSegmentWithNumberLiteralPaginationValueSegment(), 
+                getRowCountSegmentWithNumberLiteralPaginationValueSegment(), getParameters()).getActualOffset(), is(30L));
     }
     
     @Test
     public void assertGetActualOffsetWithNullOffsetSegment() {
-        assertThat(new Pagination(null, getRowCountSegment(), getParameters()).getActualOffset(), is(0L));
+        assertThat(new PaginationContext(null, getRowCountSegment(), getParameters()).getActualOffset(), is(0L));
     }
     
     @Test
     public void assertGetActualRowCount() {
-        assertThat(new Pagination(getOffsetSegment(), getRowCountSegment(), getParameters()).getActualRowCount().orNull(), is(20L));
+        assertThat(new PaginationContext(getOffsetSegment(), getRowCountSegment(), getParameters()).getActualRowCount().orNull(), is(20L));
     }
     
     @Test
     public void assertGetActualRowCountWithNumberLiteralPaginationValueSegment() {
-        assertThat(new Pagination(getOffsetSegmentWithNumberLiteralPaginationValueSegment(),
+        assertThat(new PaginationContext(getOffsetSegmentWithNumberLiteralPaginationValueSegment(),
             getRowCountSegmentWithNumberLiteralPaginationValueSegment(), getParameters()).getActualRowCount().orNull(), is(20L));
     }
     
     @Test
     public void assertGetActualRowCountWithNullRowCountSegment() {
-        assertNull(new Pagination(getOffsetSegment(), null, getParameters()).getActualRowCount().orNull());
+        assertNull(new PaginationContext(getOffsetSegment(), null, getParameters()).getActualRowCount().orNull());
     }
     
     private PaginationValueSegment getOffsetSegmentWithNumberLiteralPaginationValueSegment() {
@@ -102,12 +99,12 @@ public class PaginationTest {
     
     @Test
     public void assertGetOffsetParameterIndex() {
-        assertThat(new Pagination(getOffsetSegment(), getRowCountSegment(), getParameters()).getOffsetParameterIndex().orNull(), is(0));
+        assertThat(new PaginationContext(getOffsetSegment(), getRowCountSegment(), getParameters()).getOffsetParameterIndex().orNull(), is(0));
     }
     
     @Test
     public void assertGetRowCountParameterIndex() {
-        assertThat(new Pagination(getOffsetSegment(), getRowCountSegment(), getParameters()).getRowCountParameterIndex().orNull(), is(1));
+        assertThat(new PaginationContext(getOffsetSegment(), getRowCountSegment(), getParameters()).getRowCountParameterIndex().orNull(), is(1));
     }
     
     private PaginationValueSegment getOffsetSegment() {
@@ -124,43 +121,22 @@ public class PaginationTest {
     
     @Test
     public void assertGetRevisedOffset() {
-        assertThat(new Pagination(getOffsetSegment(), getRowCountSegment(), getParameters()).getRevisedOffset(), is(0L));
+        assertThat(new PaginationContext(getOffsetSegment(), getRowCountSegment(), getParameters()).getRevisedOffset(), is(0L));
     }
     
     @Test
     public void getRevisedRowCount() {
-        SelectOptimizedStatement shardingStatement = mock(SelectOptimizedStatement.class);
-        Mockito.doReturn(getSelectItemsWithEmptyAggregationSelectItems()).when(shardingStatement).getSelectItems();
-        doReturn(getGroupByWithEmptyItems()).when(shardingStatement).getGroupBy();
-        assertThat(new Pagination(getOffsetSegment(), getRowCountSegment(), getParameters()).getRevisedRowCount(shardingStatement), is(50L));
-    }
-    
-    private GroupBy getGroupByWithEmptyItems() {
-        GroupBy groupBy = mock(GroupBy.class);
-        when(groupBy.getItems()).thenReturn(Collections.<OrderByItem>emptyList());
-        return groupBy;
-    }
-    
-    private SelectItems getSelectItemsWithEmptyAggregationSelectItems() {
-        SelectItems selectItems = mock(SelectItems.class);
-        when(selectItems.getAggregationSelectItems()).thenReturn(Collections.<AggregationSelectItem>emptyList());
-        return selectItems;
+        SelectSQLStatementContext selectSQLStatementContext = mock(SelectSQLStatementContext.class);
+        when(selectSQLStatementContext.getSelectItemsContext()).thenReturn(mock(SelectItemsContext.class));
+        when(selectSQLStatementContext.getGroupByContext()).thenReturn(new GroupByContext(Collections.<OrderByItem>emptyList(), 0));
+        assertThat(new PaginationContext(getOffsetSegment(), getRowCountSegment(), getParameters()).getRevisedRowCount(selectSQLStatementContext), is(50L));
     }
     
     @Test
     public void getRevisedRowCountWithMax() {
-        SelectOptimizedStatement shardingStatement = mock(SelectOptimizedStatement.class);
-        doReturn(getSelectItemsWithEmptyAggregationSelectItems()).when(shardingStatement).getSelectItems();
-        doReturn(getGroupBy()).when(shardingStatement).getGroupBy();
-        doReturn(false).when(shardingStatement).isSameGroupByAndOrderByItems();
-        assertThat(new Pagination(getOffsetSegment(), getRowCountSegment(), getParameters()).getRevisedRowCount(shardingStatement), is((long) Integer.MAX_VALUE));
-    }
-    
-    private GroupBy getGroupBy() {
-        GroupBy groupBy = mock(GroupBy.class);
-        List items = mock(List.class);
-        when(items.isEmpty()).thenReturn(false);
-        when(groupBy.getItems()).thenReturn(items);
-        return groupBy;
+        SelectSQLStatementContext selectSQLStatementContext = mock(SelectSQLStatementContext.class);
+        when(selectSQLStatementContext.getSelectItemsContext()).thenReturn(mock(SelectItemsContext.class));
+        when(selectSQLStatementContext.getGroupByContext()).thenReturn(new GroupByContext(Collections.singletonList(mock(OrderByItem.class)), 1));
+        assertThat(new PaginationContext(getOffsetSegment(), getRowCountSegment(), getParameters()).getRevisedRowCount(selectSQLStatementContext), is((long) Integer.MAX_VALUE));
     }
 }

sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/segment/TablesTest.java → sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/segment/table/TablesContextTest.java

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.optimize.segment;
+package org.apache.shardingsphere.core.optimize.segment.table;
 
 import com.google.common.base.Optional;
 import com.google.common.collect.Sets;
@@ -31,28 +31,28 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-public final class TablesTest {
+public final class TablesContextTest {
     
     @Test
     public void assertIsEmpty() {
-        Tables tables = new Tables(new SelectStatement());
-        assertTrue(tables.isEmpty());
+        TablesContext tablesContext = new TablesContext(new SelectStatement());
+        assertTrue(tablesContext.isEmpty());
     }
     
     @Test
     public void assertIsNotEmpty() {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table", "tbl"));
-        Tables tables = new Tables(selectStatement);
-        assertFalse(tables.isEmpty());
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        assertFalse(tablesContext.isEmpty());
     }
     
     @Test
     public void assertIsSingleTable() {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table", "tbl"));
-        Tables tables = new Tables(selectStatement);
-        assertTrue(tables.isSingleTable());
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        assertTrue(tablesContext.isSingleTable());
     }
     
     @Test
@@ -60,8 +60,8 @@ public final class TablesTest {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table", "tbl"));
         selectStatement.getAllSQLSegments().add(createTableSegment("Table", null));
-        Tables tables = new Tables(selectStatement);
-        assertTrue(tables.isSingleTable());
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        assertTrue(tablesContext.isSingleTable());
     }
     
     @Test
@@ -69,8 +69,8 @@ public final class TablesTest {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table", "tbl"));
         selectStatement.getAllSQLSegments().add(createTableSegment("tbl", null));
-        Tables tables = new Tables(selectStatement);
-        assertTrue(tables.isSingleTable());
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        assertTrue(tablesContext.isSingleTable());
     }
     
     @Test
@@ -78,16 +78,16 @@ public final class TablesTest {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table_1", "tbl_1"));
         selectStatement.getAllSQLSegments().add(createTableSegment("table_2", "tbl_2"));
-        Tables tables = new Tables(selectStatement);
-        assertFalse(tables.isSingleTable());
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        assertFalse(tablesContext.isSingleTable());
     }
     
     @Test
     public void assertGetSingleTableName() {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table", "tbl"));
-        Tables tables = new Tables(selectStatement);
-        assertThat(tables.getSingleTableName(), is("table"));
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        assertThat(tablesContext.getSingleTableName(), is("table"));
     }
     
     @Test
@@ -95,8 +95,8 @@ public final class TablesTest {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table_1", "tbl_1"));
         selectStatement.getAllSQLSegments().add(createTableSegment("table_2", "tbl_2"));
-        Tables tables = new Tables(selectStatement);
-        assertThat(tables.getTableNames(), CoreMatchers.<Collection<String>>is(Sets.newHashSet("table_1", "table_2")));
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        assertThat(tablesContext.getTableNames(), CoreMatchers.<Collection<String>>is(Sets.newHashSet("table_1", "table_2")));
     }
     
     @Test
@@ -104,8 +104,8 @@ public final class TablesTest {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table_1", "tbl_1"));
         selectStatement.getAllSQLSegments().add(createTableSegment("table_2", "tbl_2"));
-        Tables tables = new Tables(selectStatement);
-        Optional<Table> table = tables.find("table_1");
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        Optional<Table> table = tablesContext.find("table_1");
         assertTrue(table.isPresent());
         assertThat(table.get().getName(), is("table_1"));
         assertThat(table.get().getAlias().orNull(), is("tbl_1"));
@@ -116,8 +116,8 @@ public final class TablesTest {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table_1", "tbl_1"));
         selectStatement.getAllSQLSegments().add(createTableSegment("table_2", "tbl_2"));
-        Tables tables = new Tables(selectStatement);
-        Optional<Table> table = tables.find("tbl_1");
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        Optional<Table> table = tablesContext.find("tbl_1");
         assertTrue(table.isPresent());
         assertThat(table.get().getName(), is("table_1"));
         assertThat(table.get().getAlias().orNull(), is("tbl_1"));
@@ -128,8 +128,8 @@ public final class TablesTest {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(createTableSegment("table_1", "tbl_1"));
         selectStatement.getAllSQLSegments().add(createTableSegment("table_2", "tbl_2"));
-        Tables tables = new Tables(selectStatement);
-        Optional<Table> table = tables.find("table_3");
+        TablesContext tablesContext = new TablesContext(selectStatement);
+        Optional<Table> table = tablesContext.find("table_3");
         assertFalse(table.isPresent());
     }
     

sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/statement/impl/InsertOptimizeStatementTest.java → sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/statement/impl/InsertSQLStatementContextTest.java

@@ -18,7 +18,6 @@
 package org.apache.shardingsphere.core.optimize.statement.impl;
 
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.assignment.InsertValuesSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.ExpressionSegment;
@@ -35,27 +34,27 @@ import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-public final class InsertOptimizeStatementTest {
+public final class InsertSQLStatementContextTest {
     
     @Test
-    public void assertInsertOptimizedStatementWithColumnNames() {
+    public void assertInsertSQLStatementContextWithColumnNames() {
         InsertStatement insertStatement = new InsertStatement();
         insertStatement.getAllSQLSegments().add(new TableSegment(0, 0, "tbl"));
         insertStatement.getColumns().addAll(Arrays.asList(new ColumnSegment(0, 0, "id"), new ColumnSegment(0, 0, "name"), new ColumnSegment(0, 0, "status")));
         setUpInsertValues(insertStatement);
-        InsertOptimizedStatement actual = new InsertOptimizedStatement(mock(TableMetas.class), Arrays.<Object>asList(1, "Tom", 2, "Jerry"), insertStatement);
-        assertInsertOptimizeStatement(actual);
+        InsertSQLStatementContext actual = new InsertSQLStatementContext(mock(TableMetas.class), Arrays.<Object>asList(1, "Tom", 2, "Jerry"), insertStatement);
+        assertInsertSQLStatementContext(actual);
     }
     
     @Test
-    public void assertInsertOptimizedStatementWithoutColumnNames() {
+    public void assertInsertSQLStatementContextWithoutColumnNames() {
         TableMetas tableMetas = mock(TableMetas.class);
         when(tableMetas.getAllColumnNames("tbl")).thenReturn(Arrays.asList("id", "name", "status"));
         InsertStatement insertStatement = new InsertStatement();
         insertStatement.getAllSQLSegments().add(new TableSegment(0, 0, "tbl"));
         setUpInsertValues(insertStatement);
-        InsertOptimizedStatement actual = new InsertOptimizedStatement(tableMetas, Arrays.<Object>asList(1, "Tom", 2, "Jerry"), insertStatement);
-        assertInsertOptimizeStatement(actual);
+        InsertSQLStatementContext actual = new InsertSQLStatementContext(tableMetas, Arrays.<Object>asList(1, "Tom", 2, "Jerry"), insertStatement);
+        assertInsertSQLStatementContext(actual);
     }
     
     private void setUpInsertValues(final InsertStatement insertStatement) {
@@ -65,15 +64,15 @@ public final class InsertOptimizeStatementTest {
                 new ParameterMarkerExpressionSegment(0, 0, 3), new ParameterMarkerExpressionSegment(0, 0, 4), new LiteralExpressionSegment(0, 0, "init"))));
     }
     
-    private void assertInsertOptimizeStatement(final InsertOptimizedStatement actual) {
-        assertThat(actual.getTables().getSingleTableName(), is("tbl"));
+    private void assertInsertSQLStatementContext(final InsertSQLStatementContext actual) {
+        assertThat(actual.getTablesContext().getSingleTableName(), is("tbl"));
         assertThat(actual.getColumnNames(), is(Arrays.asList("id", "name", "status")));
-        assertThat(actual.getInsertValues().size(), is(2));
-        assertThat(actual.getInsertValues().get(0).getValue(0), is((Object) 1));
-        assertThat(actual.getInsertValues().get(0).getValue(1), is((Object) "Tom"));
-        assertThat(actual.getInsertValues().get(0).getValue(2), is((Object) "init"));
-        assertThat(actual.getInsertValues().get(1).getValue(0), is((Object) 2));
-        assertThat(actual.getInsertValues().get(1).getValue(1), is((Object) "Jerry"));
-        assertThat(actual.getInsertValues().get(1).getValue(2), is((Object) "init"));
+        assertThat(actual.getInsertValueContexts().size(), is(2));
+        assertThat(actual.getInsertValueContexts().get(0).getValue(0), is((Object) 1));
+        assertThat(actual.getInsertValueContexts().get(0).getValue(1), is((Object) "Tom"));
+        assertThat(actual.getInsertValueContexts().get(0).getValue(2), is((Object) "init"));
+        assertThat(actual.getInsertValueContexts().get(1).getValue(0), is((Object) 2));
+        assertThat(actual.getInsertValueContexts().get(1).getValue(1), is((Object) "Jerry"));
+        assertThat(actual.getInsertValueContexts().get(1).getValue(2), is((Object) "init"));
     }
 }

sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/statement/impl/SelectOptimizedStatementTest.java → sharding-core/sharding-core-optimize/src/test/java/org/apache/shardingsphere/core/optimize/statement/impl/SelectSQLStatementContextTest.java

@@ -18,11 +18,11 @@
 package org.apache.shardingsphere.core.optimize.statement.impl;
 
 import com.google.common.collect.Lists;
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.ColumnSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
 import org.apache.shardingsphere.core.parse.core.constant.OrderDirection;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.column.ColumnSegment;
@@ -46,7 +46,7 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-public final class SelectOptimizedStatementTest {
+public final class SelectSQLStatementContextTest {
     
     private static final String INDEX_ORDER_BY = "IndexOrderBy";
     
@@ -58,38 +58,38 @@ public final class SelectOptimizedStatementTest {
     
     @Test
     public void assertSetIndexForItemsByIndexOrderBy() {
-        SelectOptimizedStatement selectOptimizedStatement = new SelectOptimizedStatement(
-                new SelectStatement(), new GroupBy(Collections.<OrderByItem>emptyList(), 0), createOrderBy(INDEX_ORDER_BY), createSelectItems(), null);
-        selectOptimizedStatement.setIndexForItems(Collections.<String, Integer>emptyMap());
-        assertThat(selectOptimizedStatement.getOrderBy().getItems().iterator().next().getIndex(), is(4));
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(
+                new SelectStatement(), new GroupByContext(Collections.<OrderByItem>emptyList(), 0), createOrderBy(INDEX_ORDER_BY), createSelectItems(), null);
+        selectSQLStatementContext.setIndexForItems(Collections.<String, Integer>emptyMap());
+        assertThat(selectSQLStatementContext.getOrderByContext().getItems().iterator().next().getIndex(), is(4));
     }
     
     @Test
     public void assertSetIndexForItemsByColumnOrderByWithOwner() {
-        SelectOptimizedStatement selectOptimizedStatement = new SelectOptimizedStatement(
-                new SelectStatement(), new GroupBy(Collections.<OrderByItem>emptyList(), 0), createOrderBy(COLUMN_ORDER_BY_WITH_OWNER), createSelectItems(), null);
-        selectOptimizedStatement.setIndexForItems(Collections.<String, Integer>emptyMap());
-        assertThat(selectOptimizedStatement.getOrderBy().getItems().iterator().next().getIndex(), is(1));
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(
+                new SelectStatement(), new GroupByContext(Collections.<OrderByItem>emptyList(), 0), createOrderBy(COLUMN_ORDER_BY_WITH_OWNER), createSelectItems(), null);
+        selectSQLStatementContext.setIndexForItems(Collections.<String, Integer>emptyMap());
+        assertThat(selectSQLStatementContext.getOrderByContext().getItems().iterator().next().getIndex(), is(1));
     }
     
     @Test
     public void assertSetIndexForItemsByColumnOrderByWithAlias() {
-        SelectOptimizedStatement selectOptimizedStatement = new SelectOptimizedStatement(
-                new SelectStatement(), new GroupBy(Collections.<OrderByItem>emptyList(), 0), createOrderBy(COLUMN_ORDER_BY_WITH_ALIAS), createSelectItems(), null);
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(
+                new SelectStatement(), new GroupByContext(Collections.<OrderByItem>emptyList(), 0), createOrderBy(COLUMN_ORDER_BY_WITH_ALIAS), createSelectItems(), null);
         Map<String, Integer> columnLabelIndexMap = new HashMap<>();
         columnLabelIndexMap.put("n", 2);
-        selectOptimizedStatement.setIndexForItems(columnLabelIndexMap);
-        assertThat(selectOptimizedStatement.getOrderBy().getItems().iterator().next().getIndex(), is(2));
+        selectSQLStatementContext.setIndexForItems(columnLabelIndexMap);
+        assertThat(selectSQLStatementContext.getOrderByContext().getItems().iterator().next().getIndex(), is(2));
     }
     
     @Test
     public void assertSetIndexForItemsByColumnOrderByWithoutAlias() {
-        SelectOptimizedStatement selectOptimizedStatement = new SelectOptimizedStatement(
-                new SelectStatement(), new GroupBy(Collections.<OrderByItem>emptyList(), 0), createOrderBy(COLUMN_ORDER_BY_WITHOUT_OWNER_ALIAS), createSelectItems(), null);
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(
+                new SelectStatement(), new GroupByContext(Collections.<OrderByItem>emptyList(), 0), createOrderBy(COLUMN_ORDER_BY_WITHOUT_OWNER_ALIAS), createSelectItems(), null);
         Map<String, Integer> columnLabelIndexMap = new HashMap<>();
         columnLabelIndexMap.put("id", 3);
-        selectOptimizedStatement.setIndexForItems(columnLabelIndexMap);
-        assertThat(selectOptimizedStatement.getOrderBy().getItems().iterator().next().getIndex(), is(3));
+        selectSQLStatementContext.setIndexForItems(columnLabelIndexMap);
+        assertThat(selectSQLStatementContext.getOrderByContext().getItems().iterator().next().getIndex(), is(3));
     }
     
     @Test
@@ -98,16 +98,16 @@ public final class SelectOptimizedStatementTest {
         selectStatement.setSelectItems(new SelectItemsSegment(0, 0, false));
         selectStatement.setGroupBy(new GroupBySegment(0, 0, Collections.<OrderByItemSegment>singletonList(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.DESC))));
         selectStatement.setOrderBy(new OrderBySegment(0, 0, Collections.<OrderByItemSegment>singletonList(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.DESC))));
-        SelectOptimizedStatement selectOptimizedStatement = new SelectOptimizedStatement(null, "", Collections.emptyList(), selectStatement);
-        assertTrue(selectOptimizedStatement.isSameGroupByAndOrderByItems());
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(null, "", Collections.emptyList(), selectStatement);
+        assertTrue(selectSQLStatementContext.isSameGroupByAndOrderByItems());
     }
     
     @Test
     public void assertIsNotSameGroupByAndOrderByItemsWhenEmptyGroupBy() {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.setSelectItems(new SelectItemsSegment(0, 0, false));
-        SelectOptimizedStatement selectOptimizedStatement = new SelectOptimizedStatement(null, "", Collections.emptyList(), selectStatement);
-        assertFalse(selectOptimizedStatement.isSameGroupByAndOrderByItems());
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(null, "", Collections.emptyList(), selectStatement);
+        assertFalse(selectSQLStatementContext.isSameGroupByAndOrderByItems());
     }
     
     @Test
@@ -116,14 +116,14 @@ public final class SelectOptimizedStatementTest {
         selectStatement.setSelectItems(new SelectItemsSegment(0, 0, false));
         selectStatement.setGroupBy(new GroupBySegment(0, 0, Collections.<OrderByItemSegment>singletonList(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.DESC))));
         selectStatement.setOrderBy(new OrderBySegment(0, 0, Collections.<OrderByItemSegment>singletonList(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.DESC))));
-        SelectOptimizedStatement selectOptimizedStatement = new SelectOptimizedStatement(null, "", Collections.emptyList(), selectStatement);
-        assertFalse(selectOptimizedStatement.isSameGroupByAndOrderByItems());
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(null, "", Collections.emptyList(), selectStatement);
+        assertFalse(selectSQLStatementContext.isSameGroupByAndOrderByItems());
     }
     
-    private OrderBy createOrderBy(final String type) {
+    private OrderByContext createOrderBy(final String type) {
         OrderByItemSegment orderByItemSegment = createOrderByItemSegment(type);
         OrderByItem orderByItem = new OrderByItem(orderByItemSegment);
-        return new OrderBy(Lists.newArrayList(orderByItem), true);
+        return new OrderByContext(Lists.newArrayList(orderByItem), true);
     }
     
     private OrderByItemSegment createOrderByItemSegment(final String type) {
@@ -141,9 +141,9 @@ public final class SelectOptimizedStatementTest {
         }
     }
     
-    private SelectItems createSelectItems() {
+    private SelectItemsContext createSelectItems() {
         Collection<SelectItem> selectItems = Lists.newArrayList(getColumnSelectItemWithoutOwner(), getColumnSelectItemWithoutOwner(true), getColumnSelectItemWithoutOwner(false));
-        return new SelectItems(0, 0, true, selectItems);
+        return new SelectItemsContext(0, 0, true, selectItems);
     }
     
     private SelectItem getColumnSelectItemWithoutOwner() {

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/SQLRewriteEngine.java

@@ -18,9 +18,9 @@
 package org.apache.shardingsphere.core.rewrite;
 
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.segment.insert.InsertValue;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.insert.InsertValueContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.group.GroupedParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.standard.StandardParameterBuilder;
@@ -75,8 +75,8 @@ public final class SQLRewriteEngine {
         sqlBuilder = new SQLBuilder(sql, sqlTokens);
     }
     
-    public SQLRewriteEngine(final EncryptRule encryptRule, final TableMetas tableMetas, 
-                            final OptimizedStatement encryptStatement, final String sql, final List<Object> parameters, final boolean isQueryWithCipherColumn) {
+    public SQLRewriteEngine(final EncryptRule encryptRule, final TableMetas tableMetas,
+                            final SQLStatementContext encryptStatement, final String sql, final List<Object> parameters, final boolean isQueryWithCipherColumn) {
         baseRule = encryptRule;
         rewriteStatement = RewriteStatementFactory.newInstance(encryptRule, tableMetas, encryptStatement);
         parameterBuilder = createParameterBuilder(parameters);
@@ -84,28 +84,28 @@ public final class SQLRewriteEngine {
         sqlBuilder = new SQLBuilder(sql, sqlTokens);
     }
     
-    public SQLRewriteEngine(final MasterSlaveRule masterSlaveRule, final OptimizedStatement optimizedStatement, final String sql) {
+    public SQLRewriteEngine(final MasterSlaveRule masterSlaveRule, final SQLStatementContext sqlStatementContext, final String sql) {
         baseRule = masterSlaveRule;
         rewriteStatement = new RewriteStatement(
-                optimizedStatement, new ShardingConditions(Collections.<ShardingCondition>emptyList()), new EncryptConditions(Collections.<EncryptCondition>emptyList()));
+                sqlStatementContext, new ShardingConditions(Collections.<ShardingCondition>emptyList()), new EncryptConditions(Collections.<EncryptCondition>emptyList()));
         parameterBuilder = createParameterBuilder(Collections.emptyList());
         sqlTokens = createSQLTokens(false, false);
         sqlBuilder = new SQLBuilder(sql, sqlTokens);
     }
     
     private ParameterBuilder createParameterBuilder(final List<Object> parameters, final SQLRouteResult sqlRouteResult) {
-        return rewriteStatement.getOptimizedStatement() instanceof InsertOptimizedStatement
+        return rewriteStatement.getSqlStatementContext() instanceof InsertSQLStatementContext
                 ? new GroupedParameterBuilder(parameters, getGroupedParameters(), rewriteStatement.getShardingConditions()) : new StandardParameterBuilder(parameters, sqlRouteResult);
     }
     
     private ParameterBuilder createParameterBuilder(final List<Object> parameters) {
-        return rewriteStatement.getOptimizedStatement() instanceof InsertOptimizedStatement
+        return rewriteStatement.getSqlStatementContext() instanceof InsertSQLStatementContext
                 ? new GroupedParameterBuilder(parameters, getGroupedParameters(), null) : new StandardParameterBuilder(parameters);
     }
     
     private List<List<Object>> getGroupedParameters() {
         List<List<Object>> result = new LinkedList<>();
-        for (InsertValue each : ((InsertOptimizedStatement) rewriteStatement.getOptimizedStatement()).getInsertValues()) {
+        for (InsertValueContext each : ((InsertSQLStatementContext) rewriteStatement.getSqlStatementContext()).getInsertValueContexts()) {
             result.add(each.getParameters());
         }
         return result;

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/builder/parameter/standard/StandardParameterBuilder.java

@@ -19,8 +19,8 @@ package org.apache.shardingsphere.core.rewrite.builder.parameter.standard;
 
 import com.google.common.base.Optional;
 import lombok.Getter;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
 import org.apache.shardingsphere.core.route.type.RoutingUnit;
@@ -57,7 +57,7 @@ public final class StandardParameterBuilder implements ParameterBuilder {
     
     private void setReplacedIndexAndParameters(final SQLRouteResult sqlRouteResult) {
         if (isNeedRewritePagination(sqlRouteResult)) {
-            Pagination pagination = ((SelectOptimizedStatement) sqlRouteResult.getShardingStatement()).getPagination();
+            PaginationContext pagination = ((SelectSQLStatementContext) sqlRouteResult.getShardingStatementContext()).getPaginationContext();
             Optional<Integer> offsetParameterIndex = pagination.getOffsetParameterIndex();
             if (offsetParameterIndex.isPresent()) {
                 rewriteOffset(pagination, offsetParameterIndex.get());
@@ -70,16 +70,16 @@ public final class StandardParameterBuilder implements ParameterBuilder {
     }
     
     private boolean isNeedRewritePagination(final SQLRouteResult sqlRouteResult) {
-        return sqlRouteResult.getShardingStatement() instanceof SelectOptimizedStatement
-                && ((SelectOptimizedStatement) sqlRouteResult.getShardingStatement()).getPagination().isHasPagination() && !sqlRouteResult.getRoutingResult().isSingleRouting();
+        return sqlRouteResult.getShardingStatementContext() instanceof SelectSQLStatementContext
+                && ((SelectSQLStatementContext) sqlRouteResult.getShardingStatementContext()).getPaginationContext().isHasPagination() && !sqlRouteResult.getRoutingResult().isSingleRouting();
     }
     
-    private void rewriteOffset(final Pagination pagination, final int offsetParameterIndex) {
+    private void rewriteOffset(final PaginationContext pagination, final int offsetParameterIndex) {
         replacedIndexAndParameters.put(offsetParameterIndex, pagination.getRevisedOffset());
     }
     
-    private void rewriteRowCount(final Pagination pagination, final int rowCountParameterIndex, final SQLRouteResult sqlRouteResult) {
-        replacedIndexAndParameters.put(rowCountParameterIndex, pagination.getRevisedRowCount((SelectOptimizedStatement) sqlRouteResult.getShardingStatement()));
+    private void rewriteRowCount(final PaginationContext pagination, final int rowCountParameterIndex, final SQLRouteResult sqlRouteResult) {
+        replacedIndexAndParameters.put(rowCountParameterIndex, pagination.getRevisedRowCount((SelectSQLStatementContext) sqlRouteResult.getShardingStatementContext()));
     }
     
     @Override

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/encrypt/WhereClauseEncryptConditionEngine.java

@@ -21,7 +21,7 @@ import com.google.common.base.Optional;
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.core.exception.ShardingException;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.segment.Tables;
+import org.apache.shardingsphere.core.optimize.segment.table.TablesContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.simple.SimpleExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.predicate.AndPredicate;
@@ -68,24 +68,24 @@ public final class WhereClauseEncryptConditionEngine {
             return Collections.emptyList();
         }
         List<EncryptCondition> result = new LinkedList<>();
-        Tables tables = new Tables(sqlStatement);
+        TablesContext tablesContext = new TablesContext(sqlStatement);
         for (AndPredicate each : whereSegment.get().getAndPredicates()) {
-            result.addAll(createEncryptConditions(each, tables));
+            result.addAll(createEncryptConditions(each, tablesContext));
         }
         for (SubqueryPredicateSegment each : sqlStatement.findSQLSegments(SubqueryPredicateSegment.class)) {
             for (AndPredicate andPredicate : each.getAndPredicates()) {
-                result.addAll(createEncryptConditions(andPredicate, tables));
+                result.addAll(createEncryptConditions(andPredicate, tablesContext));
             }
         }
         return result;
     }
 
-    private Collection<EncryptCondition> createEncryptConditions(final AndPredicate andPredicate, final Tables tables) {
+    private Collection<EncryptCondition> createEncryptConditions(final AndPredicate andPredicate, final TablesContext tablesContext) {
         Collection<EncryptCondition> result = new LinkedList<>();
         Collection<Integer> stopIndexes = new HashSet<>();
         for (PredicateSegment predicate : andPredicate.getPredicates()) {
             if (stopIndexes.add(predicate.getStopIndex())) {
-                Optional<EncryptCondition> condition = createEncryptCondition(predicate, tables);
+                Optional<EncryptCondition> condition = createEncryptCondition(predicate, tablesContext);
                 if (condition.isPresent()) {
                     result.add(condition.get());
                 }
@@ -94,8 +94,8 @@ public final class WhereClauseEncryptConditionEngine {
         return result;
     }
     
-    private Optional<EncryptCondition> createEncryptCondition(final PredicateSegment predicateSegment, final Tables tables) {
-        Optional<String> tableName = tables.findTableName(predicateSegment.getColumn(), tableMetas);
+    private Optional<EncryptCondition> createEncryptCondition(final PredicateSegment predicateSegment, final TablesContext tablesContext) {
+        Optional<String> tableName = tablesContext.findTableName(predicateSegment.getColumn(), tableMetas);
         return tableName.isPresent() && encryptRule.findShardingEncryptor(tableName.get(), predicateSegment.getColumn().getName()).isPresent()
                 ? createEncryptCondition(predicateSegment, tableName.get()) : Optional.<EncryptCondition>absent();
     }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/statement/InsertRewriteStatement.java

@@ -19,8 +19,8 @@ package org.apache.shardingsphere.core.rewrite.statement;
 
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
-import org.apache.shardingsphere.core.optimize.segment.insert.InsertValue;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.insert.InsertValueContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
 import org.apache.shardingsphere.core.rewrite.encrypt.EncryptConditions;
 import org.apache.shardingsphere.core.rewrite.statement.constant.EncryptDerivedColumnType;
 import org.apache.shardingsphere.core.rewrite.statement.constant.ShardingDerivedColumnType;
@@ -42,25 +42,25 @@ public final class InsertRewriteStatement extends RewriteStatement {
     
     private final GeneratedKey generatedKey;
     
-    public InsertRewriteStatement(final InsertOptimizedStatement optimizedStatement, 
+    public InsertRewriteStatement(final InsertSQLStatementContext insertSQLStatementContext, 
                                   final ShardingConditions shardingConditions, final EncryptConditions encryptConditions, final GeneratedKey generatedKey, final EncryptRule encryptRule) {
-        super(optimizedStatement, shardingConditions, encryptConditions);
+        super(insertSQLStatementContext, shardingConditions, encryptConditions);
         this.generatedKey = generatedKey;
-        processGeneratedKey(optimizedStatement);
-        processEncrypt(optimizedStatement, encryptRule);
+        processGeneratedKey(insertSQLStatementContext);
+        processEncrypt(insertSQLStatementContext, encryptRule);
     }
     
-    private void processGeneratedKey(final InsertOptimizedStatement optimizedStatement) {
+    private void processGeneratedKey(final InsertSQLStatementContext insertSQLStatementContext) {
         if (null != generatedKey && generatedKey.isGenerated()) {
             Iterator<Comparable<?>> generatedValues = generatedKey.getGeneratedValues().descendingIterator();
-            for (InsertValue each : optimizedStatement.getInsertValues()) {
+            for (InsertValueContext each : insertSQLStatementContext.getInsertValueContexts()) {
                 each.appendValue(generatedValues.next(), ShardingDerivedColumnType.KEY_GEN);
             }
         }
     }
     
-    private void processEncrypt(final InsertOptimizedStatement optimizedStatement, final EncryptRule encryptRule) {
-        String tableName = optimizedStatement.getTables().getSingleTableName();
+    private void processEncrypt(final InsertSQLStatementContext insertSQLStatementContext, final EncryptRule encryptRule) {
+        String tableName = insertSQLStatementContext.getTablesContext().getSingleTableName();
         Optional<EncryptTable> encryptTable = encryptRule.findEncryptTable(tableName);
         if (!encryptTable.isPresent()) {
             return;
@@ -68,30 +68,30 @@ public final class InsertRewriteStatement extends RewriteStatement {
         for (String each : encryptTable.get().getLogicColumns()) {
             Optional<ShardingEncryptor> shardingEncryptor = encryptRule.findShardingEncryptor(tableName, each);
             if (shardingEncryptor.isPresent()) {
-                encryptInsertValues(optimizedStatement, encryptRule, shardingEncryptor.get(), tableName, each);
+                encryptInsertValues(insertSQLStatementContext, encryptRule, shardingEncryptor.get(), tableName, each);
             }
         }
     }
     
-    private void encryptInsertValues(final InsertOptimizedStatement optimizedStatement, final EncryptRule encryptRule, final ShardingEncryptor shardingEncryptor,
+    private void encryptInsertValues(final InsertSQLStatementContext insertSQLStatementContext, final EncryptRule encryptRule, final ShardingEncryptor shardingEncryptor,
                                      final String tableName, final String encryptLogicColumnName) {
-        int columnIndex = optimizedStatement.getColumnNames().indexOf(encryptLogicColumnName);
-        for (InsertValue each : optimizedStatement.getInsertValues()) {
+        int columnIndex = insertSQLStatementContext.getColumnNames().indexOf(encryptLogicColumnName);
+        for (InsertValueContext each : insertSQLStatementContext.getInsertValueContexts()) {
             encryptInsertValue(encryptRule, shardingEncryptor, tableName, columnIndex, each, encryptLogicColumnName);
         }
     }
     
     private void encryptInsertValue(final EncryptRule encryptRule, final ShardingEncryptor shardingEncryptor,
-                                    final String tableName, final int columnIndex, final InsertValue insertValue, final String encryptLogicColumnName) {
-        Object originalValue = insertValue.getValue(columnIndex);
-        insertValue.setValue(columnIndex, shardingEncryptor.encrypt(originalValue));
+                                    final String tableName, final int columnIndex, final InsertValueContext insertValueContext, final String encryptLogicColumnName) {
+        Object originalValue = insertValueContext.getValue(columnIndex);
+        insertValueContext.setValue(columnIndex, shardingEncryptor.encrypt(originalValue));
         if (shardingEncryptor instanceof ShardingQueryAssistedEncryptor) {
             Optional<String> assistedColumnName = encryptRule.findAssistedQueryColumn(tableName, encryptLogicColumnName);
             Preconditions.checkArgument(assistedColumnName.isPresent(), "Can not find assisted query Column Name");
-            insertValue.appendValue(((ShardingQueryAssistedEncryptor) shardingEncryptor).queryAssistedEncrypt(originalValue.toString()), EncryptDerivedColumnType.ENCRYPT);
+            insertValueContext.appendValue(((ShardingQueryAssistedEncryptor) shardingEncryptor).queryAssistedEncrypt(originalValue.toString()), EncryptDerivedColumnType.ENCRYPT);
         }
         if (encryptRule.findPlainColumn(tableName, encryptLogicColumnName).isPresent()) {
-            insertValue.appendValue(originalValue, EncryptDerivedColumnType.ENCRYPT);
+            insertValueContext.appendValue(originalValue, EncryptDerivedColumnType.ENCRYPT);
         }
     }
     

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/statement/RewriteStatement.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.core.rewrite.statement;
 
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.rewrite.encrypt.EncryptConditions;
 import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingConditions;
 
@@ -32,7 +32,7 @@ import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingCo
 @Getter
 public class RewriteStatement {
     
-    private final OptimizedStatement optimizedStatement;
+    private final SQLStatementContext sqlStatementContext;
     
     private final ShardingConditions shardingConditions;
     

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/statement/RewriteStatementFactory.java

@@ -20,8 +20,8 @@ package org.apache.shardingsphere.core.rewrite.statement;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.DMLStatement;
 import org.apache.shardingsphere.core.rewrite.encrypt.EncryptCondition;
 import org.apache.shardingsphere.core.rewrite.encrypt.EncryptConditions;
@@ -51,14 +51,14 @@ public final class RewriteStatementFactory {
      * @return rewrite statement
      */
     public static RewriteStatement newInstance(final ShardingRule shardingRule, final TableMetas tableMetas, final SQLRouteResult sqlRouteResult) {
-        EncryptConditions encryptConditions = sqlRouteResult.getEncryptStatement().getSqlStatement() instanceof DMLStatement
-                ? createEncryptConditions(shardingRule.getEncryptRule(), tableMetas, (DMLStatement) sqlRouteResult.getEncryptStatement().getSqlStatement())
+        EncryptConditions encryptConditions = sqlRouteResult.getEncryptStatementContext().getSqlStatement() instanceof DMLStatement
+                ? createEncryptConditions(shardingRule.getEncryptRule(), tableMetas, (DMLStatement) sqlRouteResult.getEncryptStatementContext().getSqlStatement())
                 : new EncryptConditions(Collections.<EncryptCondition>emptyList());
-        return sqlRouteResult.getShardingStatement() instanceof InsertOptimizedStatement
+        return sqlRouteResult.getShardingStatementContext() instanceof InsertSQLStatementContext
                 ? new InsertRewriteStatement(
-                        (InsertOptimizedStatement) sqlRouteResult.getShardingStatement(), sqlRouteResult.getShardingConditions(), encryptConditions, 
+                        (InsertSQLStatementContext) sqlRouteResult.getShardingStatementContext(), sqlRouteResult.getShardingConditions(), encryptConditions, 
                         sqlRouteResult.getGeneratedKey().orNull(), shardingRule.getEncryptRule())
-                : new RewriteStatement(sqlRouteResult.getShardingStatement(), sqlRouteResult.getShardingConditions(), encryptConditions);
+                : new RewriteStatement(sqlRouteResult.getShardingStatementContext(), sqlRouteResult.getShardingConditions(), encryptConditions);
     }
     
     /**
@@ -66,16 +66,16 @@ public final class RewriteStatementFactory {
      * 
      * @param encryptRule encrypt rule
      * @param tableMetas table metas
-     * @param encryptStatement encrypt statement
+     * @param sqlStatementContext SQL statement context
      * @return rewrite statement
      */
-    public static RewriteStatement newInstance(final EncryptRule encryptRule, final TableMetas tableMetas, final OptimizedStatement encryptStatement) {
+    public static RewriteStatement newInstance(final EncryptRule encryptRule, final TableMetas tableMetas, final SQLStatementContext sqlStatementContext) {
         ShardingConditions shardingConditions = new ShardingConditions(Collections.<ShardingCondition>emptyList());
-        EncryptConditions encryptConditions = encryptStatement.getSqlStatement() instanceof DMLStatement
-                ? createEncryptConditions(encryptRule, tableMetas, (DMLStatement) encryptStatement.getSqlStatement()) : new EncryptConditions(Collections.<EncryptCondition>emptyList());
-        return encryptStatement instanceof InsertOptimizedStatement
-                ? new InsertRewriteStatement((InsertOptimizedStatement) encryptStatement, shardingConditions, encryptConditions, null, encryptRule)
-                : new RewriteStatement(encryptStatement, shardingConditions, encryptConditions);
+        EncryptConditions encryptConditions = sqlStatementContext.getSqlStatement() instanceof DMLStatement
+                ? createEncryptConditions(encryptRule, tableMetas, (DMLStatement) sqlStatementContext.getSqlStatement()) : new EncryptConditions(Collections.<EncryptCondition>emptyList());
+        return sqlStatementContext instanceof InsertSQLStatementContext
+                ? new InsertRewriteStatement((InsertSQLStatementContext) sqlStatementContext, shardingConditions, encryptConditions, null, encryptRule)
+                : new RewriteStatement(sqlStatementContext, shardingConditions, encryptConditions);
     }
     
     private static EncryptConditions createEncryptConditions(final EncryptRule encryptRule, final TableMetas tableMetas, final DMLStatement sqlStatement) {

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/AggregationDistinctTokenGenerator.java

@@ -20,7 +20,7 @@ package org.apache.shardingsphere.core.rewrite.token.generator;
 import com.google.common.base.Preconditions;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationDistinctSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.DerivedColumn;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.statement.RewriteStatement;
 import org.apache.shardingsphere.core.rewrite.token.pojo.AggregationDistinctToken;
@@ -40,11 +40,11 @@ public final class AggregationDistinctTokenGenerator implements CollectionSQLTok
     @Override
     public Collection<AggregationDistinctToken> generateSQLTokens(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final ShardingRule shardingRule, final boolean isQueryWithCipherColumn) {
-        if (!(rewriteStatement.getOptimizedStatement() instanceof SelectOptimizedStatement)) {
+        if (!(rewriteStatement.getSqlStatementContext() instanceof SelectSQLStatementContext)) {
             return Collections.emptyList();
         }
         Collection<AggregationDistinctToken> result = new LinkedList<>();
-        for (AggregationDistinctSelectItem each : ((SelectOptimizedStatement) rewriteStatement.getOptimizedStatement()).getSelectItems().getAggregationDistinctSelectItems()) {
+        for (AggregationDistinctSelectItem each : ((SelectSQLStatementContext) rewriteStatement.getSqlStatementContext()).getSelectItemsContext().getAggregationDistinctSelectItems()) {
             result.add(createAggregationDistinctToken(each));
         }
         return result;

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/IndexTokenGenerator.java

@@ -39,7 +39,7 @@ public final class IndexTokenGenerator implements CollectionSQLTokenGenerator<Sh
     public Collection<IndexToken> generateSQLTokens(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final ShardingRule shardingRule, final boolean isQueryWithCipherColumn) {
         Collection<IndexToken> result = new LinkedList<>();
-        for (SQLSegment each : rewriteStatement.getOptimizedStatement().getSqlStatement().getAllSQLSegments()) {
+        for (SQLSegment each : rewriteStatement.getSqlStatementContext().getSqlStatement().getAllSQLSegments()) {
             if (each instanceof IndexSegment) {
                 result.add(createIndexToken((IndexSegment) each));
             }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/InsertCipherNameTokenGenerator.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.column.InsertColumnsSegment;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
@@ -42,23 +42,23 @@ public final class InsertCipherNameTokenGenerator implements CollectionSQLTokenG
     @Override
     public Collection<InsertCipherNameToken> generateSQLTokens(final RewriteStatement rewriteStatement,
                                                                final ParameterBuilder parameterBuilder, final EncryptRule rule, final boolean isQueryWithCipherColumn) {
-        if (!isNeedToGenerateSQLToken(rewriteStatement.getOptimizedStatement())) {
+        if (!isNeedToGenerateSQLToken(rewriteStatement.getSqlStatementContext())) {
             return Collections.emptyList();
         }
-        return createInsertColumnTokens((InsertOptimizedStatement) rewriteStatement.getOptimizedStatement(), rule);
+        return createInsertColumnTokens((InsertSQLStatementContext) rewriteStatement.getSqlStatementContext(), rule);
     }
     
-    private boolean isNeedToGenerateSQLToken(final OptimizedStatement optimizedStatement) {
-        Optional<InsertColumnsSegment> insertColumnsSegment = optimizedStatement.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
-        return optimizedStatement instanceof InsertOptimizedStatement && insertColumnsSegment.isPresent() && !insertColumnsSegment.get().getColumns().isEmpty();
+    private boolean isNeedToGenerateSQLToken(final SQLStatementContext sqlStatementContext) {
+        Optional<InsertColumnsSegment> insertColumnsSegment = sqlStatementContext.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
+        return sqlStatementContext instanceof InsertSQLStatementContext && insertColumnsSegment.isPresent() && !insertColumnsSegment.get().getColumns().isEmpty();
     }
     
-    private Collection<InsertCipherNameToken> createInsertColumnTokens(final InsertOptimizedStatement optimizedStatement, final EncryptRule encryptRule) {
-        Optional<InsertColumnsSegment> insertColumnsSegment = optimizedStatement.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
+    private Collection<InsertCipherNameToken> createInsertColumnTokens(final InsertSQLStatementContext insertSQLStatementContext, final EncryptRule encryptRule) {
+        Optional<InsertColumnsSegment> insertColumnsSegment = insertSQLStatementContext.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
         if (!insertColumnsSegment.isPresent()) {
             return Collections.emptyList();
         }
-        Map<String, String> logicAndCipherColumns = encryptRule.getLogicAndCipherColumns(optimizedStatement.getTables().getSingleTableName());
+        Map<String, String> logicAndCipherColumns = encryptRule.getLogicAndCipherColumns(insertSQLStatementContext.getTablesContext().getSingleTableName());
         Collection<InsertCipherNameToken> result = new LinkedList<>();
         for (ColumnSegment each : insertColumnsSegment.get().getColumns()) {
             if (logicAndCipherColumns.keySet().contains(each.getName())) {

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/InsertGeneratedKeyNameTokenGenerator.java

@@ -18,7 +18,7 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.column.InsertColumnsSegment;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.statement.InsertRewriteStatement;
@@ -36,11 +36,11 @@ public final class InsertGeneratedKeyNameTokenGenerator implements OptionalSQLTo
     @Override
     public Optional<InsertGeneratedKeyNameToken> generateSQLToken(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final ShardingRule shardingRule, final boolean isQueryWithCipherColumn) {
-        Optional<InsertColumnsSegment> insertColumnsSegment = rewriteStatement.getOptimizedStatement().getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
+        Optional<InsertColumnsSegment> insertColumnsSegment = rewriteStatement.getSqlStatementContext().getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
         if (!insertColumnsSegment.isPresent() || insertColumnsSegment.get().getColumns().isEmpty()) {
             return Optional.absent();
         }
-        if (rewriteStatement.getOptimizedStatement() instanceof InsertOptimizedStatement) {
+        if (rewriteStatement.getSqlStatementContext() instanceof InsertSQLStatementContext) {
             return createInsertGeneratedKeyToken((InsertRewriteStatement) rewriteStatement, insertColumnsSegment.get(), shardingRule);
         }
         return Optional.absent();
@@ -48,7 +48,7 @@ public final class InsertGeneratedKeyNameTokenGenerator implements OptionalSQLTo
     
     private Optional<InsertGeneratedKeyNameToken> createInsertGeneratedKeyToken(
             final InsertRewriteStatement rewriteStatement, final InsertColumnsSegment segment, final ShardingRule shardingRule) {
-        String tableName = rewriteStatement.getOptimizedStatement().getTables().getSingleTableName();
+        String tableName = rewriteStatement.getSqlStatementContext().getTablesContext().getSingleTableName();
         Optional<String> generatedKeyColumnName = shardingRule.findGenerateKeyColumnName(tableName);
         return generatedKeyColumnName.isPresent() && rewriteStatement.getGeneratedKey().isPresent() && rewriteStatement.getGeneratedKey().get().isGenerated()
                 ? Optional.of(new InsertGeneratedKeyNameToken(segment.getStopIndex(), generatedKeyColumnName.get(), isToAddCloseParenthesis(tableName, segment, shardingRule)))

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/InsertQueryAndPlainNamesTokenGenerator.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.column.InsertColumnsSegment;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.statement.RewriteStatement;
@@ -41,23 +41,23 @@ public final class InsertQueryAndPlainNamesTokenGenerator implements OptionalSQL
     @Override
     public Optional<InsertQueryAndPlainNamesToken> generateSQLToken(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final EncryptRule encryptRule, final boolean isQueryWithCipherColumn) {
-        if (!isNeedToGenerateSQLToken(rewriteStatement.getOptimizedStatement())) {
+        if (!isNeedToGenerateSQLToken(rewriteStatement.getSqlStatementContext())) {
             return Optional.absent();
         }
-        return createInsertAssistedColumnsToken(rewriteStatement.getOptimizedStatement(), encryptRule);
+        return createInsertAssistedColumnsToken(rewriteStatement.getSqlStatementContext(), encryptRule);
     }
     
-    private boolean isNeedToGenerateSQLToken(final OptimizedStatement optimizedStatement) {
-        Optional<InsertColumnsSegment> insertColumnsSegment = optimizedStatement.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
-        return optimizedStatement instanceof InsertOptimizedStatement && insertColumnsSegment.isPresent();
+    private boolean isNeedToGenerateSQLToken(final SQLStatementContext sqlStatementContext) {
+        Optional<InsertColumnsSegment> insertColumnsSegment = sqlStatementContext.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
+        return sqlStatementContext instanceof InsertSQLStatementContext && insertColumnsSegment.isPresent();
     }
     
-    private Optional<InsertQueryAndPlainNamesToken> createInsertAssistedColumnsToken(final OptimizedStatement optimizedStatement, final EncryptRule encryptRule) {
-        Optional<InsertColumnsSegment> insertColumnsSegment = optimizedStatement.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
+    private Optional<InsertQueryAndPlainNamesToken> createInsertAssistedColumnsToken(final SQLStatementContext sqlStatementContext, final EncryptRule encryptRule) {
+        Optional<InsertColumnsSegment> insertColumnsSegment = sqlStatementContext.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
         if (!insertColumnsSegment.isPresent()) {
             return Optional.absent();
         }
-        String tableName = optimizedStatement.getTables().getSingleTableName();
+        String tableName = sqlStatementContext.getTablesContext().getSingleTableName();
         return encryptRule.getAssistedQueryAndPlainColumns(tableName).isEmpty() ? Optional.<InsertQueryAndPlainNamesToken>absent()
                 : Optional.of(new InsertQueryAndPlainNamesToken(
                         insertColumnsSegment.get().getStopIndex(), getEncryptDerivedColumnNames(tableName, encryptRule), insertColumnsSegment.get().getColumns().isEmpty()));

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/InsertRegularNamesTokenGenerator.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.column.InsertColumnsSegment;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.statement.InsertRewriteStatement;
@@ -44,32 +44,32 @@ public final class InsertRegularNamesTokenGenerator implements OptionalSQLTokenG
     @Override
     public Optional<InsertRegularNamesToken> generateSQLToken(final RewriteStatement rewriteStatement,
                                                               final ParameterBuilder parameterBuilder, final BaseRule baseRule, final boolean isQueryWithCipherColumn) {
-        if (!isNeedToGenerateSQLToken(rewriteStatement.getOptimizedStatement(), baseRule)) {
+        if (!isNeedToGenerateSQLToken(rewriteStatement.getSqlStatementContext(), baseRule)) {
             return Optional.absent();
         }
         return createInsertColumnsToken(rewriteStatement, baseRule);
     }
     
-    private boolean isNeedToGenerateSQLToken(final OptimizedStatement optimizedStatement, final BaseRule baseRule) {
-        Optional<InsertColumnsSegment> insertColumnsSegment = optimizedStatement.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
+    private boolean isNeedToGenerateSQLToken(final SQLStatementContext sqlStatementContext, final BaseRule baseRule) {
+        Optional<InsertColumnsSegment> insertColumnsSegment = sqlStatementContext.getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
         return !(baseRule instanceof MasterSlaveRule) 
-                && optimizedStatement instanceof InsertOptimizedStatement && insertColumnsSegment.isPresent() && insertColumnsSegment.get().getColumns().isEmpty();
+                && sqlStatementContext instanceof InsertSQLStatementContext && insertColumnsSegment.isPresent() && insertColumnsSegment.get().getColumns().isEmpty();
     }
     
     private Optional<InsertRegularNamesToken> createInsertColumnsToken(final RewriteStatement rewriteStatement, final BaseRule baseRule) {
-        Optional<InsertColumnsSegment> insertColumnsSegment = rewriteStatement.getOptimizedStatement().getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
+        Optional<InsertColumnsSegment> insertColumnsSegment = rewriteStatement.getSqlStatementContext().getSqlStatement().findSQLSegment(InsertColumnsSegment.class);
         return insertColumnsSegment.isPresent()
                 ? Optional.of(new InsertRegularNamesToken(insertColumnsSegment.get().getStopIndex(), 
-                getActualInsertColumns((InsertRewriteStatement) rewriteStatement, baseRule), !isNeedToAppendColumns((InsertOptimizedStatement) rewriteStatement.getOptimizedStatement(), baseRule)))
+                getActualInsertColumns((InsertRewriteStatement) rewriteStatement, baseRule), !isNeedToAppendColumns((InsertSQLStatementContext) rewriteStatement.getSqlStatementContext(), baseRule)))
                 : Optional.<InsertRegularNamesToken>absent();
     }
     
     private Collection<String> getActualInsertColumns(final InsertRewriteStatement rewriteStatement, final BaseRule baseRule) {
         Collection<String> result = new LinkedList<>();
-        Map<String, String> logicAndCipherColumns = getEncryptRule(baseRule).getLogicAndCipherColumns(rewriteStatement.getOptimizedStatement().getTables().getSingleTableName());
-        boolean isGeneratedKey = rewriteStatement.getOptimizedStatement() instanceof InsertOptimizedStatement 
+        Map<String, String> logicAndCipherColumns = getEncryptRule(baseRule).getLogicAndCipherColumns(rewriteStatement.getSqlStatementContext().getTablesContext().getSingleTableName());
+        boolean isGeneratedKey = rewriteStatement.getSqlStatementContext() instanceof InsertSQLStatementContext 
                 && (rewriteStatement.getGeneratedKey().isPresent() && (rewriteStatement.getGeneratedKey().get().isGenerated()));
-        for (String each : ((InsertOptimizedStatement) rewriteStatement.getOptimizedStatement()).getColumnNames()) {
+        for (String each : ((InsertSQLStatementContext) rewriteStatement.getSqlStatementContext()).getColumnNames()) {
             if (!isGeneratedKey || !each.equalsIgnoreCase(rewriteStatement.getGeneratedKey().get().getColumnName())) {
                 result.add(logicAndCipherColumns.keySet().contains(each) ? logicAndCipherColumns.get(each) : each);
             }
@@ -84,16 +84,16 @@ public final class InsertRegularNamesTokenGenerator implements OptionalSQLTokenG
         return baseRule instanceof ShardingRule ? ((ShardingRule) baseRule).getEncryptRule() : (EncryptRule) baseRule;
     }
     
-    private boolean isNeedToAppendColumns(final InsertOptimizedStatement optimizedStatement, final BaseRule baseRule) {
+    private boolean isNeedToAppendColumns(final InsertSQLStatementContext insertSQLStatementContext, final BaseRule baseRule) {
         return baseRule instanceof ShardingRule
-                ? isNeedToAppendColumns(optimizedStatement, (ShardingRule) baseRule) : isNeedToAppendAssistedQueryAndPlainColumns(optimizedStatement, (EncryptRule) baseRule);
+                ? isNeedToAppendColumns(insertSQLStatementContext, (ShardingRule) baseRule) : isNeedToAppendAssistedQueryAndPlainColumns(insertSQLStatementContext, (EncryptRule) baseRule);
     }
     
-    private boolean isNeedToAppendColumns(final InsertOptimizedStatement optimizedStatement, final ShardingRule shardingRule) {
-        return isNeedToAppendAssistedQueryAndPlainColumns(optimizedStatement, shardingRule.getEncryptRule());
+    private boolean isNeedToAppendColumns(final InsertSQLStatementContext insertSQLStatementContext, final ShardingRule shardingRule) {
+        return isNeedToAppendAssistedQueryAndPlainColumns(insertSQLStatementContext, shardingRule.getEncryptRule());
     }
     
-    private boolean isNeedToAppendAssistedQueryAndPlainColumns(final OptimizedStatement optimizedStatement, final EncryptRule encryptRule) {
-        return !encryptRule.getAssistedQueryAndPlainColumns(optimizedStatement.getTables().getSingleTableName()).isEmpty();
+    private boolean isNeedToAppendAssistedQueryAndPlainColumns(final SQLStatementContext sqlStatementContext, final EncryptRule encryptRule) {
+        return !encryptRule.getAssistedQueryAndPlainColumns(sqlStatementContext.getTablesContext().getSingleTableName()).isEmpty();
     }
 }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/InsertSetCipherColumnTokenGenerator.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.assignment.AssignmentSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.assignment.SetAssignmentsSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.ExpressionSegment;
@@ -45,25 +45,25 @@ public final class InsertSetCipherColumnTokenGenerator implements CollectionSQLT
     @Override
     public Collection<InsertSetCipherColumnToken> generateSQLTokens(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final EncryptRule encryptRule, final boolean isQueryWithCipherColumn) {
-        if (!isNeedToGenerateSQLToken(rewriteStatement.getOptimizedStatement())) {
+        if (!isNeedToGenerateSQLToken(rewriteStatement.getSqlStatementContext())) {
             return Collections.emptyList();
         }
-        return createInsertSetEncryptValueTokens((InsertOptimizedStatement) rewriteStatement.getOptimizedStatement(), encryptRule);
+        return createInsertSetEncryptValueTokens((InsertSQLStatementContext) rewriteStatement.getSqlStatementContext(), encryptRule);
     }
     
-    private boolean isNeedToGenerateSQLToken(final OptimizedStatement optimizedStatement) {
-        Optional<SetAssignmentsSegment> setAssignmentsSegment = optimizedStatement.getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
-        return optimizedStatement.getSqlStatement() instanceof InsertStatement && setAssignmentsSegment.isPresent();
+    private boolean isNeedToGenerateSQLToken(final SQLStatementContext sqlStatementContext) {
+        Optional<SetAssignmentsSegment> setAssignmentsSegment = sqlStatementContext.getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
+        return sqlStatementContext.getSqlStatement() instanceof InsertStatement && setAssignmentsSegment.isPresent();
     }
     
-    private Collection<InsertSetCipherColumnToken> createInsertSetEncryptValueTokens(final InsertOptimizedStatement optimizedStatement, final EncryptRule encryptRule) {
-        Optional<SetAssignmentsSegment> setAssignmentsSegment = optimizedStatement.getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
+    private Collection<InsertSetCipherColumnToken> createInsertSetEncryptValueTokens(final InsertSQLStatementContext insertSQLStatementContext, final EncryptRule encryptRule) {
+        Optional<SetAssignmentsSegment> setAssignmentsSegment = insertSQLStatementContext.getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
         if (!setAssignmentsSegment.isPresent()) {
             return Collections.emptyList();
         }
         Collection<InsertSetCipherColumnToken> result = new LinkedList<>();
         for (AssignmentSegment each : setAssignmentsSegment.get().getAssignments()) {
-            Optional<InsertSetCipherColumnToken> insertSetEncryptValueToken = createInsertSetEncryptValueToken(optimizedStatement, encryptRule, each);
+            Optional<InsertSetCipherColumnToken> insertSetEncryptValueToken = createInsertSetEncryptValueToken(insertSQLStatementContext, encryptRule, each);
             if (insertSetEncryptValueToken.isPresent()) {
                 result.add(insertSetEncryptValueToken.get());
             }
@@ -71,19 +71,20 @@ public final class InsertSetCipherColumnTokenGenerator implements CollectionSQLT
         return result;
     }
     
-    private Optional<InsertSetCipherColumnToken> createInsertSetEncryptValueToken(final InsertOptimizedStatement optimizedStatement, final EncryptRule encryptRule, final AssignmentSegment segment) {
-        String tableName = optimizedStatement.getTables().getSingleTableName();
+    private Optional<InsertSetCipherColumnToken> createInsertSetEncryptValueToken(final InsertSQLStatementContext insertSQLStatementContext, 
+                                                                                  final EncryptRule encryptRule, final AssignmentSegment segment) {
+        String tableName = insertSQLStatementContext.getTablesContext().getSingleTableName();
         Optional<ShardingEncryptor> shardingEncryptor = encryptRule.findShardingEncryptor(tableName, segment.getColumn().getName());
         if (shardingEncryptor.isPresent()) {
             String cipherColumnName = encryptRule.getCipherColumn(tableName, segment.getColumn().getName());
-            ExpressionSegment cipherValue = getCipherValue(optimizedStatement, segment);
+            ExpressionSegment cipherValue = getCipherValue(insertSQLStatementContext, segment);
             return Optional.of(new InsertSetCipherColumnToken(segment.getStartIndex(), segment.getStopIndex(), cipherColumnName, cipherValue));
         }
         return Optional.absent();
     }
     
-    private ExpressionSegment getCipherValue(final InsertOptimizedStatement optimizedStatement, final AssignmentSegment assignmentSegment) {
+    private ExpressionSegment getCipherValue(final InsertSQLStatementContext insertSQLStatementContext, final AssignmentSegment assignmentSegment) {
         return assignmentSegment.getValue() instanceof ParameterMarkerExpressionSegment ? assignmentSegment.getValue()
-                : optimizedStatement.getInsertValues().get(0).getValueExpressions().get(optimizedStatement.getColumnNames().indexOf(assignmentSegment.getColumn().getName()));
+                : insertSQLStatementContext.getInsertValueContexts().get(0).getValueExpressions().get(insertSQLStatementContext.getColumnNames().indexOf(assignmentSegment.getColumn().getName()));
     }
 }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/InsertSetGeneratedKeyColumnTokenGenerator.java

@@ -18,7 +18,7 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.assignment.AssignmentSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.assignment.SetAssignmentsSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.ExpressionSegment;
@@ -40,31 +40,32 @@ public final class InsertSetGeneratedKeyColumnTokenGenerator implements Optional
     @Override
     public Optional<InsertSetGeneratedKeyColumnToken> generateSQLToken(final RewriteStatement rewriteStatement, 
                                                                        final ParameterBuilder parameterBuilder, final ShardingRule shardingRule, final boolean isQueryWithCipherColumn) {
-        Optional<SetAssignmentsSegment> setAssignmentsSegment = rewriteStatement.getOptimizedStatement().getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
-        if (!(rewriteStatement.getOptimizedStatement() instanceof InsertOptimizedStatement && setAssignmentsSegment.isPresent())) {
+        Optional<SetAssignmentsSegment> setAssignmentsSegment = rewriteStatement.getSqlStatementContext().getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
+        if (!(rewriteStatement.getSqlStatementContext() instanceof InsertSQLStatementContext && setAssignmentsSegment.isPresent())) {
             return Optional.absent();
         }
-        return createInsertSetGeneratedKeyColumnToken((InsertOptimizedStatement) rewriteStatement.getOptimizedStatement(), shardingRule, setAssignmentsSegment.get());
+        return createInsertSetGeneratedKeyColumnToken((InsertSQLStatementContext) rewriteStatement.getSqlStatementContext(), shardingRule, setAssignmentsSegment.get());
     }
     
-    private Optional<InsertSetGeneratedKeyColumnToken> createInsertSetGeneratedKeyColumnToken(final InsertOptimizedStatement optimizedStatement, 
+    private Optional<InsertSetGeneratedKeyColumnToken> createInsertSetGeneratedKeyColumnToken(final InsertSQLStatementContext insertSQLStatementContext, 
                                                                                               final ShardingRule shardingRule, final SetAssignmentsSegment segment) {
-        Optional<String> generatedKeyColumn = getGeneratedKeyColumn(optimizedStatement, shardingRule);
+        Optional<String> generatedKeyColumn = getGeneratedKeyColumn(insertSQLStatementContext, shardingRule);
         if (generatedKeyColumn.isPresent()) {
-            return Optional.of(createInsertSetGeneratedKeyColumnToken(optimizedStatement, generatedKeyColumn.get(), new ArrayList<>(segment.getAssignments())));
+            return Optional.of(createInsertSetGeneratedKeyColumnToken(insertSQLStatementContext, generatedKeyColumn.get(), new ArrayList<>(segment.getAssignments())));
         }
         return Optional.absent();
     }
     
-    private InsertSetGeneratedKeyColumnToken createInsertSetGeneratedKeyColumnToken(final InsertOptimizedStatement optimizedStatement, 
+    private InsertSetGeneratedKeyColumnToken createInsertSetGeneratedKeyColumnToken(final InsertSQLStatementContext insertSQLStatementContext, 
                                                                                     final String generatedKeyColumn, final List<AssignmentSegment> assignments) {
-        int index = optimizedStatement.getColumnNames().contains(generatedKeyColumn) ? optimizedStatement.getColumnNames().indexOf(generatedKeyColumn) : optimizedStatement.getColumnNames().size();
-        ExpressionSegment expressionSegment = optimizedStatement.getInsertValues().get(0).getValueExpressions().get(index);
+        int index = insertSQLStatementContext.getColumnNames().contains(generatedKeyColumn)
+                ? insertSQLStatementContext.getColumnNames().indexOf(generatedKeyColumn) : insertSQLStatementContext.getColumnNames().size();
+        ExpressionSegment expressionSegment = insertSQLStatementContext.getInsertValueContexts().get(0).getValueExpressions().get(index);
         return new InsertSetGeneratedKeyColumnToken(assignments.get(assignments.size() - 1).getStopIndex() + 1, generatedKeyColumn, expressionSegment);
     }
     
-    private Optional<String> getGeneratedKeyColumn(final InsertOptimizedStatement optimizedStatement, final ShardingRule shardingRule) {
-        Optional<String> generateKeyColumn = shardingRule.findGenerateKeyColumnName(optimizedStatement.getTables().getSingleTableName());
-        return generateKeyColumn.isPresent() && !optimizedStatement.getColumnNames().contains(generateKeyColumn.get()) ? generateKeyColumn : Optional.<String>absent();
+    private Optional<String> getGeneratedKeyColumn(final InsertSQLStatementContext insertSQLStatementContext, final ShardingRule shardingRule) {
+        Optional<String> generateKeyColumn = shardingRule.findGenerateKeyColumnName(insertSQLStatementContext.getTablesContext().getSingleTableName());
+        return generateKeyColumn.isPresent() && !insertSQLStatementContext.getColumnNames().contains(generateKeyColumn.get()) ? generateKeyColumn : Optional.<String>absent();
     }
 }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/InsertSetQueryAndPlainColumnsTokenGenerator.java

@@ -20,8 +20,8 @@ package org.apache.shardingsphere.core.rewrite.token.generator;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import org.apache.shardingsphere.core.optimize.segment.insert.expression.DerivedSimpleExpressionSegment;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.rewrite.statement.constant.EncryptDerivedColumnType;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.assignment.AssignmentSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.assignment.SetAssignmentsSegment;
@@ -47,24 +47,24 @@ public final class InsertSetQueryAndPlainColumnsTokenGenerator implements Option
     @Override
     public Optional<InsertSetQueryAndPlainColumnsToken> generateSQLToken(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final EncryptRule encryptRule, final boolean isQueryWithCipherColumn) {
-        if (!isNeedToGenerateSQLToken(rewriteStatement.getOptimizedStatement())) {
+        if (!isNeedToGenerateSQLToken(rewriteStatement.getSqlStatementContext())) {
             return Optional.absent();
         }
-        return createInsertSetAddItemsToken((InsertOptimizedStatement) rewriteStatement.getOptimizedStatement(), encryptRule);
+        return createInsertSetAddItemsToken((InsertSQLStatementContext) rewriteStatement.getSqlStatementContext(), encryptRule);
     }
     
-    private boolean isNeedToGenerateSQLToken(final OptimizedStatement optimizedStatement) {
-        Optional<SetAssignmentsSegment> setAssignmentsSegment = optimizedStatement.getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
-        return optimizedStatement instanceof InsertOptimizedStatement && setAssignmentsSegment.isPresent();
+    private boolean isNeedToGenerateSQLToken(final SQLStatementContext sqlStatementContext) {
+        Optional<SetAssignmentsSegment> setAssignmentsSegment = sqlStatementContext.getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
+        return sqlStatementContext instanceof InsertSQLStatementContext && setAssignmentsSegment.isPresent();
     }
     
-    private Optional<InsertSetQueryAndPlainColumnsToken> createInsertSetAddItemsToken(final InsertOptimizedStatement optimizedStatement, final EncryptRule encryptRule) {
-        String tableName = optimizedStatement.getTables().getSingleTableName();
+    private Optional<InsertSetQueryAndPlainColumnsToken> createInsertSetAddItemsToken(final InsertSQLStatementContext insertSQLStatementContext, final EncryptRule encryptRule) {
+        String tableName = insertSQLStatementContext.getTablesContext().getSingleTableName();
         if (encryptRule.getAssistedQueryAndPlainColumns(tableName).isEmpty()) {
             return Optional.absent();
         }
         List<String> encryptDerivedColumnNames = getEncryptDerivedColumnNames(tableName, encryptRule);
-        return Optional.of(new InsertSetQueryAndPlainColumnsToken(getStartIndex(optimizedStatement), encryptDerivedColumnNames, getEncryptDerivedValues(optimizedStatement)));
+        return Optional.of(new InsertSetQueryAndPlainColumnsToken(getStartIndex(insertSQLStatementContext), encryptDerivedColumnNames, getEncryptDerivedValues(insertSQLStatementContext)));
     }
     
     private List<String> getEncryptDerivedColumnNames(final String tableName, final EncryptRule encryptRule) {
@@ -86,16 +86,16 @@ public final class InsertSetQueryAndPlainColumnsTokenGenerator implements Option
         return result;
     }
     
-    private int getStartIndex(final InsertOptimizedStatement optimizedStatement) {
-        Optional<SetAssignmentsSegment> setAssignmentsSegment = optimizedStatement.getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
+    private int getStartIndex(final InsertSQLStatementContext insertSQLStatementContext) {
+        Optional<SetAssignmentsSegment> setAssignmentsSegment = insertSQLStatementContext.getSqlStatement().findSQLSegment(SetAssignmentsSegment.class);
         Preconditions.checkState(setAssignmentsSegment.isPresent());
         List<AssignmentSegment> assignments = new ArrayList<>(setAssignmentsSegment.get().getAssignments());
         return assignments.get(assignments.size() - 1).getStopIndex() + 1;
     }
     
-    private List<ExpressionSegment> getEncryptDerivedValues(final InsertOptimizedStatement optimizedStatement) {
+    private List<ExpressionSegment> getEncryptDerivedValues(final InsertSQLStatementContext insertSQLStatementContext) {
         List<ExpressionSegment> result = new LinkedList<>();
-        for (ExpressionSegment each : optimizedStatement.getInsertValues().get(0).getValueExpressions()) {
+        for (ExpressionSegment each : insertSQLStatementContext.getInsertValueContexts().get(0).getValueExpressions()) {
             if (each instanceof DerivedSimpleExpressionSegment && EncryptDerivedColumnType.ENCRYPT.equals(((DerivedSimpleExpressionSegment) each).getType())) { 
                 result.add(each);
             }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/InsertValuesTokenGenerator.java

@@ -18,9 +18,9 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.segment.insert.InsertValue;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.insert.InsertValueContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.assignment.InsertValuesSegment;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.InsertStatement;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
@@ -44,22 +44,22 @@ public final class InsertValuesTokenGenerator implements OptionalSQLTokenGenerat
     @Override
     public Optional<InsertValuesToken> generateSQLToken(final RewriteStatement rewriteStatement, 
                                                         final ParameterBuilder parameterBuilder, final EncryptRule encryptRule, final boolean isQueryWithCipherColumn) {
-        Collection<InsertValuesSegment> insertValuesSegments = rewriteStatement.getOptimizedStatement().getSqlStatement().findSQLSegments(InsertValuesSegment.class);
-        return isNeedToGenerateSQLToken(rewriteStatement.getOptimizedStatement(), insertValuesSegments)
+        Collection<InsertValuesSegment> insertValuesSegments = rewriteStatement.getSqlStatementContext().getSqlStatement().findSQLSegments(InsertValuesSegment.class);
+        return isNeedToGenerateSQLToken(rewriteStatement.getSqlStatementContext(), insertValuesSegments)
                 ? Optional.of(createInsertValuesToken(rewriteStatement, insertValuesSegments)) : Optional.<InsertValuesToken>absent();
     }
     
-    private boolean isNeedToGenerateSQLToken(final OptimizedStatement optimizedStatement, final Collection<InsertValuesSegment> insertValuesSegments) {
-        return optimizedStatement.getSqlStatement() instanceof InsertStatement && !insertValuesSegments.isEmpty();
+    private boolean isNeedToGenerateSQLToken(final SQLStatementContext sqlStatementContext, final Collection<InsertValuesSegment> insertValuesSegments) {
+        return sqlStatementContext.getSqlStatement() instanceof InsertStatement && !insertValuesSegments.isEmpty();
     }
     
     private InsertValuesToken createInsertValuesToken(final RewriteStatement rewriteStatement, final Collection<InsertValuesSegment> insertValuesSegments) {
         InsertValuesToken result = new InsertValuesToken(getStartIndex(insertValuesSegments), getStopIndex(insertValuesSegments));
         Iterator<ShardingCondition> shardingConditions = null;
-        if (rewriteStatement.getOptimizedStatement() instanceof InsertOptimizedStatement) {
+        if (rewriteStatement.getSqlStatementContext() instanceof InsertSQLStatementContext) {
             shardingConditions = rewriteStatement.getShardingConditions().getConditions().isEmpty() ? null : rewriteStatement.getShardingConditions().getConditions().iterator();
         }
-        for (InsertValue each : ((InsertOptimizedStatement) rewriteStatement.getOptimizedStatement()).getInsertValues()) {
+        for (InsertValueContext each : ((InsertSQLStatementContext) rewriteStatement.getSqlStatementContext()).getInsertValueContexts()) {
             Collection<DataNode> dataNodes = null == shardingConditions ? Collections.<DataNode>emptyList() : shardingConditions.next().getDataNodes();
             result.addInsertValueToken(each.getValueExpressions(), dataNodes);
         }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/OffsetTokenGenerator.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.NumberLiteralPaginationValueSegment;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.statement.RewriteStatement;
@@ -36,10 +36,10 @@ public final class OffsetTokenGenerator implements OptionalSQLTokenGenerator<Sha
     @Override
     public Optional<OffsetToken> generateSQLToken(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final ShardingRule shardingRule, final boolean isQueryWithCipherColumn) {
-        if (!(rewriteStatement.getOptimizedStatement() instanceof SelectOptimizedStatement)) {
+        if (!(rewriteStatement.getSqlStatementContext() instanceof SelectSQLStatementContext)) {
             return Optional.absent();
         }
-        Pagination pagination = ((SelectOptimizedStatement) rewriteStatement.getOptimizedStatement()).getPagination();
+        PaginationContext pagination = ((SelectSQLStatementContext) rewriteStatement.getSqlStatementContext()).getPaginationContext();
         return pagination.getOffsetSegment().isPresent() && pagination.getOffsetSegment().get() instanceof NumberLiteralPaginationValueSegment
                 ? Optional.of(new OffsetToken(pagination.getOffsetSegment().get().getStartIndex(), pagination.getOffsetSegment().get().getStopIndex(), pagination.getRevisedOffset()))
                 : Optional.<OffsetToken>absent();

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/OrderByTokenGenerator.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.core.constant.QuoteCharacter;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.ColumnOrderByItemSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.order.item.ExpressionOrderByItemSegment;
@@ -38,19 +38,19 @@ public final class OrderByTokenGenerator implements OptionalSQLTokenGenerator<Sh
     @Override
     public Optional<OrderByToken> generateSQLToken(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final ShardingRule shardingRule, final boolean isQueryWithCipherColumn) {
-        if (!(rewriteStatement.getOptimizedStatement() instanceof SelectOptimizedStatement)) {
+        if (!(rewriteStatement.getSqlStatementContext() instanceof SelectSQLStatementContext)) {
             return Optional.absent();
         }
-        if (((SelectOptimizedStatement) rewriteStatement.getOptimizedStatement()).getOrderBy().isGenerated()) {
-            return Optional.of(createOrderByToken((SelectOptimizedStatement) rewriteStatement.getOptimizedStatement()));
+        if (((SelectSQLStatementContext) rewriteStatement.getSqlStatementContext()).getOrderByContext().isGenerated()) {
+            return Optional.of(createOrderByToken((SelectSQLStatementContext) rewriteStatement.getSqlStatementContext()));
         }
         return Optional.absent();
     }
     
-    private OrderByToken createOrderByToken(final SelectOptimizedStatement optimizedStatement) {
-        OrderByToken result = new OrderByToken(optimizedStatement.getGroupBy().getLastIndex() + 1);
+    private OrderByToken createOrderByToken(final SelectSQLStatementContext selectSQLStatementContext) {
+        OrderByToken result = new OrderByToken(selectSQLStatementContext.getGroupByContext().getLastIndex() + 1);
         String columnLabel;
-        for (OrderByItem each : optimizedStatement.getOrderBy().getItems()) {
+        for (OrderByItem each : selectSQLStatementContext.getOrderByContext().getItems()) {
             if (each.getSegment() instanceof ColumnOrderByItemSegment) {
                 ColumnOrderByItemSegment columnOrderByItemSegment = (ColumnOrderByItemSegment) each.getSegment();
                 QuoteCharacter quoteCharacter = columnOrderByItemSegment.getColumn().getQuoteCharacter();

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/RemoveTokenGenerator.java

@@ -38,7 +38,7 @@ public final class RemoveTokenGenerator implements CollectionSQLTokenGenerator<B
     public Collection<RemoveToken> generateSQLTokens(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final BaseRule baseRule, final boolean isQueryWithCipherColumn) {
         Collection<RemoveToken> result = new LinkedList<>();
-        for (SQLSegment each : rewriteStatement.getOptimizedStatement().getSqlStatement().getAllSQLSegments()) {
+        for (SQLSegment each : rewriteStatement.getSqlStatementContext().getSqlStatement().getAllSQLSegments()) {
             if (each instanceof RemoveAvailable) {
                 result.add(new RemoveToken(each.getStartIndex(), each.getStopIndex()));
             }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/RowCountTokenGenerator.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.pagination.NumberLiteralPaginationValueSegment;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.statement.RewriteStatement;
@@ -36,12 +36,12 @@ public final class RowCountTokenGenerator implements OptionalSQLTokenGenerator<S
     @Override
     public Optional<RowCountToken> generateSQLToken(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final ShardingRule shardingRule, final boolean isQueryWithCipherColumn) {
-        if (!(rewriteStatement.getOptimizedStatement() instanceof SelectOptimizedStatement)) {
+        if (!(rewriteStatement.getSqlStatementContext() instanceof SelectSQLStatementContext)) {
             return Optional.absent();
         }
-        Pagination pagination = ((SelectOptimizedStatement) rewriteStatement.getOptimizedStatement()).getPagination();
+        PaginationContext pagination = ((SelectSQLStatementContext) rewriteStatement.getSqlStatementContext()).getPaginationContext();
         return pagination.getRowCountSegment().isPresent() && pagination.getRowCountSegment().get() instanceof NumberLiteralPaginationValueSegment
                 ? Optional.of(new RowCountToken(pagination.getRowCountSegment().get().getStartIndex(), pagination.getRowCountSegment().get().getStopIndex(), 
-                pagination.getRevisedRowCount((SelectOptimizedStatement) rewriteStatement.getOptimizedStatement()))) : Optional.<RowCountToken>absent();
+                pagination.getRevisedRowCount((SelectSQLStatementContext) rewriteStatement.getSqlStatementContext()))) : Optional.<RowCountToken>absent();
     }
 }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/SelectEncryptItemTokenGenerator.java

@@ -18,7 +18,7 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.item.ColumnSelectItemSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.item.SelectItemSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.item.SelectItemsSegment;
@@ -44,31 +44,31 @@ public final class SelectEncryptItemTokenGenerator implements CollectionSQLToken
     @Override
     public Collection<SelectEncryptItemToken> generateSQLTokens(final RewriteStatement rewriteStatement,
                                                                 final ParameterBuilder parameterBuilder, final EncryptRule rule, final boolean isQueryWithCipherColumn) {
-        if (!isNeedToGenerateSQLToken(rewriteStatement.getOptimizedStatement())) {
+        if (!isNeedToGenerateSQLToken(rewriteStatement.getSqlStatementContext())) {
             return Collections.emptyList();
         }
-        return createSelectCipherItemTokens(rule, rewriteStatement.getOptimizedStatement(), isQueryWithCipherColumn);
+        return createSelectCipherItemTokens(rule, rewriteStatement.getSqlStatementContext(), isQueryWithCipherColumn);
     }
     
-    private boolean isNeedToGenerateSQLToken(final OptimizedStatement optimizedStatement) {
-        if (!isSelectStatementWithTable(optimizedStatement)) {
+    private boolean isNeedToGenerateSQLToken(final SQLStatementContext sqlStatementContext) {
+        if (!isSelectStatementWithTable(sqlStatementContext)) {
             return false;
         }
-        Optional<SelectItemsSegment> selectItemsSegment = optimizedStatement.getSqlStatement().findSQLSegment(SelectItemsSegment.class);
+        Optional<SelectItemsSegment> selectItemsSegment = sqlStatementContext.getSqlStatement().findSQLSegment(SelectItemsSegment.class);
         return selectItemsSegment.isPresent() && !selectItemsSegment.get().getSelectItems().isEmpty();
     }
     
-    private boolean isSelectStatementWithTable(final OptimizedStatement optimizedStatement) {
-        return optimizedStatement.getSqlStatement() instanceof SelectStatement && !optimizedStatement.getTables().isEmpty();
+    private boolean isSelectStatementWithTable(final SQLStatementContext sqlStatementContext) {
+        return sqlStatementContext.getSqlStatement() instanceof SelectStatement && !sqlStatementContext.getTablesContext().isEmpty();
     }
     
-    private Collection<SelectEncryptItemToken> createSelectCipherItemTokens(final EncryptRule encryptRule, final OptimizedStatement optimizedStatement, final boolean isQueryWithCipherColumn) {
+    private Collection<SelectEncryptItemToken> createSelectCipherItemTokens(final EncryptRule encryptRule, final SQLStatementContext sqlStatementContext, final boolean isQueryWithCipherColumn) {
         Collection<SelectEncryptItemToken> result = new LinkedList<>();
-        Optional<SelectItemsSegment> selectItemsSegment = optimizedStatement.getSqlStatement().findSQLSegment(SelectItemsSegment.class);
+        Optional<SelectItemsSegment> selectItemsSegment = sqlStatementContext.getSqlStatement().findSQLSegment(SelectItemsSegment.class);
         if (!selectItemsSegment.isPresent()) {
             return Collections.emptyList();
         }
-        String tableName = optimizedStatement.getTables().getSingleTableName();
+        String tableName = sqlStatementContext.getTablesContext().getSingleTableName();
         Optional<EncryptTable> encryptTable = encryptRule.findEncryptTable(tableName);
         if (!encryptTable.isPresent()) {
             return Collections.emptyList();

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/SelectItemPrefixTokenGenerator.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.statement.RewriteStatement;
 import org.apache.shardingsphere.core.rewrite.token.pojo.SelectItemPrefixToken;
@@ -35,10 +35,10 @@ public final class SelectItemPrefixTokenGenerator implements OptionalSQLTokenGen
     @Override
     public Optional<SelectItemPrefixToken> generateSQLToken(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final ShardingRule shardingRule, final boolean isQueryWithCipherColumn) {
-        if (!(rewriteStatement.getOptimizedStatement() instanceof SelectOptimizedStatement)) {
+        if (!(rewriteStatement.getSqlStatementContext() instanceof SelectSQLStatementContext)) {
             return Optional.absent();
         }
-        SelectItems selectItems = ((SelectOptimizedStatement) rewriteStatement.getOptimizedStatement()).getSelectItems();
+        SelectItemsContext selectItems = ((SelectSQLStatementContext) rewriteStatement.getSqlStatementContext()).getSelectItemsContext();
         return selectItems.getAggregationDistinctSelectItems().isEmpty() ? Optional.<SelectItemPrefixToken>absent() : Optional.of(new SelectItemPrefixToken(selectItems.getStartIndex()));
     }
 }

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/SelectItemsTokenGenerator.java

@@ -25,7 +25,7 @@ import org.apache.shardingsphere.core.optimize.segment.select.item.impl.Aggregat
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.DerivedSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.rewrite.builder.parameter.ParameterBuilder;
 import org.apache.shardingsphere.core.rewrite.statement.RewriteStatement;
 import org.apache.shardingsphere.core.rewrite.token.pojo.SelectItemsToken;
@@ -44,18 +44,18 @@ public final class SelectItemsTokenGenerator implements OptionalSQLTokenGenerato
     @Override
     public Optional<SelectItemsToken> generateSQLToken(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final ShardingRule shardingRule, final boolean isQueryWithCipherColumn) {
-        if (!(rewriteStatement.getOptimizedStatement() instanceof SelectOptimizedStatement)) {
+        if (!(rewriteStatement.getSqlStatementContext() instanceof SelectSQLStatementContext)) {
             return Optional.absent();
         }
-        Collection<String> derivedItemTexts = getDerivedItemTexts((SelectOptimizedStatement) rewriteStatement.getOptimizedStatement());
+        Collection<String> derivedItemTexts = getDerivedItemTexts((SelectSQLStatementContext) rewriteStatement.getSqlStatementContext());
         return derivedItemTexts.isEmpty() ? Optional.<SelectItemsToken>absent()
                 : Optional.of(
-                        new SelectItemsToken(((SelectOptimizedStatement) rewriteStatement.getOptimizedStatement()).getSelectItems().getStopIndex() + 1 + " ".length(), derivedItemTexts));
+                        new SelectItemsToken(((SelectSQLStatementContext) rewriteStatement.getSqlStatementContext()).getSelectItemsContext().getStopIndex() + 1 + " ".length(), derivedItemTexts));
     }
     
-    private Collection<String> getDerivedItemTexts(final SelectOptimizedStatement optimizedStatement) {
+    private Collection<String> getDerivedItemTexts(final SelectSQLStatementContext selectSQLStatementContext) {
         Collection<String> result = new LinkedList<>();
-        for (SelectItem each : optimizedStatement.getSelectItems().getItems()) {
+        for (SelectItem each : selectSQLStatementContext.getSelectItemsContext().getItems()) {
             if (each instanceof AggregationSelectItem && !((AggregationSelectItem) each).getDerivedAggregationItems().isEmpty()) {
                 result.addAll(Lists.transform(((AggregationSelectItem) each).getDerivedAggregationItems(), new Function<AggregationSelectItem, String>() {
                     

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/TableTokenGenerator.java

@@ -18,8 +18,8 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.segment.Table;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.table.Table;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.SQLSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.column.ColumnSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.item.SelectItemSegment;
@@ -52,16 +52,16 @@ public final class TableTokenGenerator implements CollectionSQLTokenGenerator<Ba
     public Collection<TableToken> generateSQLTokens(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final BaseRule baseRule, final boolean isQueryWithCipherColumn) {
         Collection<TableToken> result = new LinkedList<>();
-        for (SQLSegment each : rewriteStatement.getOptimizedStatement().getSqlStatement().getAllSQLSegments()) {
+        for (SQLSegment each : rewriteStatement.getSqlStatementContext().getSqlStatement().getAllSQLSegments()) {
             if (each instanceof SelectItemsSegment) {
-                result.addAll(createTableTokens(rewriteStatement.getOptimizedStatement(), baseRule, (SelectItemsSegment) each));
+                result.addAll(createTableTokens(rewriteStatement.getSqlStatementContext(), baseRule, (SelectItemsSegment) each));
             } else if (each instanceof ColumnSegment) {
-                Optional<TableToken> tableToken = createTableToken(rewriteStatement.getOptimizedStatement(), baseRule, (ColumnSegment) each);
+                Optional<TableToken> tableToken = createTableToken(rewriteStatement.getSqlStatementContext(), baseRule, (ColumnSegment) each);
                 if (tableToken.isPresent()) {
                     result.add(tableToken.get());
                 }
             } else if (each instanceof TableAvailable) {
-                Optional<TableToken> tableToken = createTableToken(rewriteStatement.getOptimizedStatement().getSqlStatement(), baseRule, (TableAvailable) each);
+                Optional<TableToken> tableToken = createTableToken(rewriteStatement.getSqlStatementContext().getSqlStatement(), baseRule, (TableAvailable) each);
                 if (tableToken.isPresent()) {
                     result.add(tableToken.get());
                 }
@@ -70,11 +70,11 @@ public final class TableTokenGenerator implements CollectionSQLTokenGenerator<Ba
         return result;
     }
     
-    private Collection<TableToken> createTableTokens(final OptimizedStatement optimizedStatement, final BaseRule baseRule, final SelectItemsSegment selectItemsSegment) {
+    private Collection<TableToken> createTableTokens(final SQLStatementContext sqlStatementContext, final BaseRule baseRule, final SelectItemsSegment selectItemsSegment) {
         Collection<TableToken> result = new LinkedList<>();
         for (SelectItemSegment each : selectItemsSegment.getSelectItems()) {
             if (each instanceof ShorthandSelectItemSegment) {
-                Optional<TableToken> tableToken = createTableToken(optimizedStatement, baseRule, (ShorthandSelectItemSegment) each);
+                Optional<TableToken> tableToken = createTableToken(sqlStatementContext, baseRule, (ShorthandSelectItemSegment) each);
                 if (tableToken.isPresent()) {
                     result.add(tableToken.get());
                 }
@@ -83,12 +83,12 @@ public final class TableTokenGenerator implements CollectionSQLTokenGenerator<Ba
         return result;
     }
     
-    private Optional<TableToken> createTableToken(final OptimizedStatement optimizedStatement, final BaseRule baseRule, final OwnerAvailable<TableSegment> segment) {
+    private Optional<TableToken> createTableToken(final SQLStatementContext sqlStatementContext, final BaseRule baseRule, final OwnerAvailable<TableSegment> segment) {
         Optional<TableSegment> owner = segment.getOwner();
         if (!owner.isPresent()) {
             return Optional.absent();
         }
-        if (isToGenerateTableToken(optimizedStatement, baseRule, owner.get())) {
+        if (isToGenerateTableToken(sqlStatementContext, baseRule, owner.get())) {
             return Optional.of(new TableToken(owner.get().getStartIndex(), owner.get().getStopIndex(), owner.get().getTableName(), owner.get().getQuoteCharacter()));
         }
         return Optional.absent();
@@ -101,9 +101,9 @@ public final class TableTokenGenerator implements CollectionSQLTokenGenerator<Ba
         return Optional.absent();
     }
     
-    private boolean isToGenerateTableToken(final OptimizedStatement optimizedStatement, final BaseRule baseRule, final TableSegment tableSegment) {
+    private boolean isToGenerateTableToken(final SQLStatementContext sqlStatementContext, final BaseRule baseRule, final TableSegment tableSegment) {
         if (baseRule instanceof ShardingRule) {
-            Optional<Table> table = optimizedStatement.getTables().find(tableSegment.getTableName());
+            Optional<Table> table = sqlStatementContext.getTablesContext().find(tableSegment.getTableName());
             return table.isPresent() && !table.get().getAlias().isPresent() && ((ShardingRule) baseRule).findTableRule(table.get().getName()).isPresent(); 
         }
         return baseRule instanceof MasterSlaveRule;

sharding-core/sharding-core-rewrite/src/main/java/org/apache/shardingsphere/core/rewrite/token/generator/UpdateEncryptColumnTokenGenerator.java

@@ -18,7 +18,7 @@
 package org.apache.shardingsphere.core.rewrite.token.generator;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.assignment.AssignmentSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
@@ -45,14 +45,14 @@ public final class UpdateEncryptColumnTokenGenerator implements CollectionSQLTok
     @Override
     public Collection<EncryptColumnToken> generateSQLTokens(
             final RewriteStatement rewriteStatement, final ParameterBuilder parameterBuilder, final EncryptRule encryptRule, final boolean isQueryWithCipherColumn) {
-        return rewriteStatement.getOptimizedStatement().getSqlStatement() instanceof UpdateStatement 
-                ? createUpdateEncryptColumnTokens(parameterBuilder, encryptRule, rewriteStatement.getOptimizedStatement()) : Collections.<EncryptColumnToken>emptyList();
+        return rewriteStatement.getSqlStatementContext().getSqlStatement() instanceof UpdateStatement 
+                ? createUpdateEncryptColumnTokens(parameterBuilder, encryptRule, rewriteStatement.getSqlStatementContext()) : Collections.<EncryptColumnToken>emptyList();
     }
     
-    private Collection<EncryptColumnToken> createUpdateEncryptColumnTokens(final ParameterBuilder parameterBuilder, final EncryptRule encryptRule, final OptimizedStatement optimizedStatement) {
+    private Collection<EncryptColumnToken> createUpdateEncryptColumnTokens(final ParameterBuilder parameterBuilder, final EncryptRule encryptRule, final SQLStatementContext sqlStatementContext) {
         Collection<EncryptColumnToken> result = new LinkedList<>();
-        String tableName = optimizedStatement.getTables().getSingleTableName();
-        for (AssignmentSegment each : ((UpdateStatement) optimizedStatement.getSqlStatement()).getSetAssignment().getAssignments()) {
+        String tableName = sqlStatementContext.getTablesContext().getSingleTableName();
+        for (AssignmentSegment each : ((UpdateStatement) sqlStatementContext.getSqlStatement()).getSetAssignment().getAssignments()) {
             if (encryptRule.findShardingEncryptor(tableName, each.getColumn().getName()).isPresent()) {
                 result.add(createUpdateEncryptColumnToken(parameterBuilder, encryptRule, tableName, each));
             }

sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/builder/parameter/standard/StandardParameterBuilderTest.java

@@ -18,9 +18,9 @@
 package org.apache.shardingsphere.core.rewrite.builder.parameter.standard;
 
 import com.google.common.base.Optional;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
 import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingCondition;
 import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingConditions;
@@ -51,15 +51,15 @@ public final class StandardParameterBuilderTest {
     }
     
     private SQLRouteResult createSQLRouteResult() {
-        Pagination pagination = mock(Pagination.class);
+        PaginationContext pagination = mock(PaginationContext.class);
         when(pagination.isHasPagination()).thenReturn(true);
         when(pagination.getOffsetParameterIndex()).thenReturn(Optional.of(2));
         when(pagination.getRowCountParameterIndex()).thenReturn(Optional.of(3));
-        when(pagination.getRevisedRowCount(any(SelectOptimizedStatement.class))).thenReturn(6L);
-        SelectOptimizedStatement shardingStatement = mock(SelectOptimizedStatement.class);
-        when(shardingStatement.getPagination()).thenReturn(pagination);
-        OptimizedStatement encryptStatement = mock(OptimizedStatement.class);
-        SQLRouteResult result = new SQLRouteResult(shardingStatement, encryptStatement, new ShardingConditions(Collections.<ShardingCondition>emptyList()), null);
+        when(pagination.getRevisedRowCount(any(SelectSQLStatementContext.class))).thenReturn(6L);
+        SelectSQLStatementContext selectSQLStatementContext = mock(SelectSQLStatementContext.class);
+        when(selectSQLStatementContext.getPaginationContext()).thenReturn(pagination);
+        SQLStatementContext sqlStatementContext = mock(SQLStatementContext.class);
+        SQLRouteResult result = new SQLRouteResult(selectSQLStatementContext, sqlStatementContext, new ShardingConditions(Collections.<ShardingCondition>emptyList()), null);
         result.setRoutingResult(new RoutingResult());
         return result;
     }

sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/rewriter/EncryptSQLRewriteEngineTest.java

@@ -23,8 +23,8 @@ import org.apache.shardingsphere.api.config.encrypt.EncryptTableRuleConfiguratio
 import org.apache.shardingsphere.api.config.encrypt.EncryptorRuleConfiguration;
 import org.apache.shardingsphere.core.database.DatabaseTypes;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
-import org.apache.shardingsphere.core.optimize.OptimizedStatementFactory;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
+import org.apache.shardingsphere.core.optimize.SQLStatementContextFactory;
 import org.apache.shardingsphere.core.parse.SQLParseEngine;
 import org.apache.shardingsphere.core.parse.sql.statement.SQLStatement;
 import org.apache.shardingsphere.core.rewrite.SQLRewriteEngine;
@@ -336,8 +336,8 @@ public final class EncryptSQLRewriteEngineTest {
     private SQLUnit getSQLUnit(final String sql, final List<Object> parameters, final boolean isQueryWithCipherColumn) {
         // TODO panjuan: should mock sqlStatement, do not call parse module on rewrite test case
         SQLStatement sqlStatement = parseEngine.parse(sql, false);
-        OptimizedStatement encryptStatement = OptimizedStatementFactory.newInstance(mock(TableMetas.class), sql, parameters, sqlStatement);
-        SQLRewriteEngine sqlRewriteEngine = new SQLRewriteEngine(encryptRule, mock(TableMetas.class), encryptStatement, sql, parameters, isQueryWithCipherColumn);
+        SQLStatementContext sqlStatementContext = SQLStatementContextFactory.newInstance(mock(TableMetas.class), sql, parameters, sqlStatement);
+        SQLRewriteEngine sqlRewriteEngine = new SQLRewriteEngine(encryptRule, mock(TableMetas.class), sqlStatementContext, sql, parameters, isQueryWithCipherColumn);
         return sqlRewriteEngine.generateSQL();
     }
 }

sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/token/SQLTokenGenerateEngineTest.java

@@ -17,14 +17,14 @@
 
 package org.apache.shardingsphere.core.rewrite.token;
 
-import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupBy;
+import org.apache.shardingsphere.core.optimize.segment.select.groupby.GroupByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.item.impl.AggregationDistinctSelectItem;
 import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItem;
-import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItems;
-import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderBy;
+import org.apache.shardingsphere.core.optimize.segment.select.item.SelectItemsContext;
+import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByContext;
 import org.apache.shardingsphere.core.optimize.segment.select.orderby.OrderByItem;
-import org.apache.shardingsphere.core.optimize.segment.select.pagination.Pagination;
-import org.apache.shardingsphere.core.optimize.statement.impl.SelectOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.select.pagination.PaginationContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.SelectSQLStatementContext;
 import org.apache.shardingsphere.core.parse.core.constant.AggregationType;
 import org.apache.shardingsphere.core.parse.sql.statement.dml.SelectStatement;
 import org.apache.shardingsphere.core.rewrite.encrypt.EncryptCondition;
@@ -60,12 +60,13 @@ public final class SQLTokenGenerateEngineTest {
     @Before
     public void setUp() {
         SelectStatement selectStatement = new SelectStatement();
-        SelectItems selectItems = new SelectItems(1, 20, false, 
+        SelectItemsContext selectItemsContext = new SelectItemsContext(1, 20, false, 
                 Collections.<SelectItem>singletonList(new AggregationDistinctSelectItem(1, 2, AggregationType.COUNT, "(DISTINCT id)", "c", "id")));
-        SelectOptimizedStatement optimizedStatement = new SelectOptimizedStatement(selectStatement,  
-                new GroupBy(Collections.<OrderByItem>emptyList(), 1), new OrderBy(Collections.<OrderByItem>emptyList(), false), selectItems, new Pagination(null, null, Collections.emptyList()));
+        SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(selectStatement,  
+                new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false), 
+                selectItemsContext, new PaginationContext(null, null, Collections.emptyList()));
         rewriteStatement = new RewriteStatement(
-                optimizedStatement, new ShardingConditions(Collections.<ShardingCondition>emptyList()), new EncryptConditions(Collections.<EncryptCondition>emptyList()));
+                selectSQLStatementContext, new ShardingConditions(Collections.<ShardingCondition>emptyList()), new EncryptConditions(Collections.<EncryptCondition>emptyList()));
     }
     
     @SuppressWarnings("unchecked")

sharding-core/sharding-core-route/src/main/java/org/apache/shardingsphere/core/route/SQLLogger.java

@@ -21,7 +21,7 @@ import com.google.common.base.Joiner;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 
 import java.util.Collection;
 import java.util.HashSet;
@@ -63,13 +63,13 @@ public final class SQLLogger {
      * 
      * @param logicSQL logic SQL
      * @param showSimple whether show SQL in simple style
-     * @param optimizedStatement optimized statement
+     * @param sqlStatementContext SQL statement context
      * @param routeUnits route units
      */
-    public static void logSQL(final String logicSQL, final boolean showSimple, final OptimizedStatement optimizedStatement, final Collection<RouteUnit> routeUnits) {
+    public static void logSQL(final String logicSQL, final boolean showSimple, final SQLStatementContext sqlStatementContext, final Collection<RouteUnit> routeUnits) {
         log("Rule Type: sharding");
         log("Logic SQL: {}", logicSQL);
-        log("SQLStatement: {}", optimizedStatement);
+        log("SQLStatement: {}", sqlStatementContext);
         if (showSimple) {
             logSimpleMode(routeUnits);
         } else {

sharding-core/sharding-core-route/src/main/java/org/apache/shardingsphere/core/route/SQLRouteResult.java

@@ -21,7 +21,7 @@ import com.google.common.base.Optional;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
-import org.apache.shardingsphere.core.optimize.statement.OptimizedStatement;
+import org.apache.shardingsphere.core.optimize.statement.SQLStatementContext;
 import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingConditions;
 import org.apache.shardingsphere.core.route.router.sharding.keygen.GeneratedKey;
 import org.apache.shardingsphere.core.route.type.RoutingResult;
@@ -41,9 +41,9 @@ import java.util.LinkedHashSet;
 @Setter
 public final class SQLRouteResult {
     
-    private final OptimizedStatement shardingStatement;
+    private final SQLStatementContext shardingStatementContext;
     
-    private final OptimizedStatement encryptStatement;
+    private final SQLStatementContext encryptStatementContext;
     
     private final ShardingConditions shardingConditions;
     
@@ -53,8 +53,8 @@ public final class SQLRouteResult {
     
     private RoutingResult routingResult;
     
-    public SQLRouteResult(final OptimizedStatement shardingStatement, final OptimizedStatement encryptStatement, final ShardingConditions shardingConditions) {
-        this(shardingStatement, encryptStatement, shardingConditions, null);
+    public SQLRouteResult(final SQLStatementContext shardingStatementContext, final SQLStatementContext encryptStatementContext, final ShardingConditions shardingConditions) {
+        this(shardingStatementContext, encryptStatementContext, shardingConditions, null);
     }
     
     /**

sharding-core/sharding-core-route/src/main/java/org/apache/shardingsphere/core/route/router/masterslave/ShardingMasterSlaveRouter.java

@@ -61,7 +61,7 @@ public final class ShardingMasterSlaveRouter {
             }
             toBeRemoved.add(each);
             String actualDataSourceName;
-            if (isMasterRoute(sqlRouteResult.getShardingStatement().getSqlStatement())) {
+            if (isMasterRoute(sqlRouteResult.getShardingStatementContext().getSqlStatement())) {
                 MasterVisitedManager.setMasterVisited();
                 actualDataSourceName = masterSlaveRule.getMasterDataSourceName();
             } else {

sharding-core/sharding-core-route/src/main/java/org/apache/shardingsphere/core/route/router/sharding/condition/engine/InsertClauseShardingConditionEngine.java

@@ -19,8 +19,8 @@ package org.apache.shardingsphere.core.route.router.sharding.condition.engine;
 
 import com.google.common.base.Preconditions;
 import lombok.RequiredArgsConstructor;
-import org.apache.shardingsphere.core.optimize.segment.insert.InsertValue;
-import org.apache.shardingsphere.core.optimize.statement.impl.InsertOptimizedStatement;
+import org.apache.shardingsphere.core.optimize.segment.insert.InsertValueContext;
+import org.apache.shardingsphere.core.optimize.statement.impl.InsertSQLStatementContext;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.ExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.simple.LiteralExpressionSegment;
 import org.apache.shardingsphere.core.parse.sql.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
@@ -49,16 +49,16 @@ public final class InsertClauseShardingConditionEngine {
     /**
      * Create sharding conditions.
      * 
-     * @param shardingStatement sharding insert optimized statement
+     * @param insertSQLStatementContext insert SQL statement context
      * @param generatedKey generated key
      * @param parameters SQL parameters
      * @return sharding conditions
      */
-    public List<ShardingCondition> createShardingConditions(final InsertOptimizedStatement shardingStatement, final GeneratedKey generatedKey, final List<Object> parameters) {
+    public List<ShardingCondition> createShardingConditions(final InsertSQLStatementContext insertSQLStatementContext, final GeneratedKey generatedKey, final List<Object> parameters) {
         List<ShardingCondition> result = new LinkedList<>();
-        String tableName = shardingStatement.getTables().getSingleTableName();
-        Collection<String> columnNames = getColumnNames(shardingStatement, generatedKey);
-        for (InsertValue each : shardingStatement.getInsertValues()) {
+        String tableName = insertSQLStatementContext.getTablesContext().getSingleTableName();
+        Collection<String> columnNames = getColumnNames(insertSQLStatementContext, generatedKey);
+        for (InsertValueContext each : insertSQLStatementContext.getInsertValueContexts()) {
             result.add(createShardingCondition(tableName, columnNames.iterator(), each, parameters));
         }
         if (null != generatedKey && generatedKey.isGenerated() && shardingRule.isShardingColumn(generatedKey.getColumnName(), tableName)) {
@@ -67,18 +67,18 @@ public final class InsertClauseShardingConditionEngine {
         return result;
     }
     
-    private Collection<String> getColumnNames(final InsertOptimizedStatement shardingStatement, final GeneratedKey generatedKey) {
+    private Collection<String> getColumnNames(final InsertSQLStatementContext insertSQLStatementContext, final GeneratedKey generatedKey) {
         if (null == generatedKey || !generatedKey.isGenerated()) {
-            return shardingStatement.getColumnNames();
+            return insertSQLStatementContext.getColumnNames();
         }
-        Collection<String> result = new LinkedList<>(shardingStatement.getColumnNames());
+        Collection<String> result = new LinkedList<>(insertSQLStatementContext.getColumnNames());
         result.remove(generatedKey.getColumnName());
         return result;
     }
     
-    private ShardingCondition createShardingCondition(final String tableName, final Iterator<String> columnNames, final InsertValue insertValue, final List<Object> parameters) {
+    private ShardingCondition createShardingCondition(final String tableName, final Iterator<String> columnNames, final InsertValueContext insertValueContext, final List<Object> parameters) {
         ShardingCondition result = new ShardingCondition();
-        for (ExpressionSegment each : insertValue.getValueExpressions()) {
+        for (ExpressionSegment each : insertValueContext.getValueExpressions()) {
             String columnName = columnNames.next();
             if (each instanceof SimpleExpressionSegment && shardingRule.isShardingColumn(columnName, tableName)) {
                 result.getRouteValues().add(new ListRouteValue<>(columnName, tableName, Collections.singletonList(getRouteValue((SimpleExpressionSegment) each, parameters))));

sharding-jdbc/sharding-jdbc-core/src/main/java/org/apache/shardingsphere/shardingjdbc/executor/BatchPreparedStatementExecutor.java

@@ -75,7 +75,7 @@ public final class BatchPreparedStatementExecutor extends AbstractStatementExecu
      * @throws SQLException SQL exception
      */
     public void init(final SQLRouteResult routeResult) throws SQLException {
-        setOptimizedStatement(routeResult.getShardingStatement());
+        setSqlStatementContext(routeResult.getShardingStatementContext());
         getExecuteGroups().addAll(obtainExecuteGroups(routeUnits));
     }