Standardize of merge engnie (#3709)

* add LocalDataMergedResult

* remove ShowDatabasesMergedResult's constructor of queryResults

* refactor LocalDataMergedResult

* add LocalDataMergedResult & SingleLocalDataMergedResult

* remove LocalMergedResultAdapter

* rename MergedResultMetaData to EncryptorMetaData

* rename ShowOtherMergedResult to TransparentMergedResult

* refactor test case for TransparentMergedResultTest

* refactor SingleLocalDataMergedResultTest

* add MultipleLocalDataMergedResultTest

* add package name of encrypt.dal and encrypt.dql

* rename EncryptMergeEngine to DQLEncryptMergeEngine

* add generic for MemoryMergedResult

* refactor EncryptResultSet's field as final

* add desc table for encrypt only

* refactor desc table for sharding + encrypt

* remove DescribeTableMergedResult from DALMergeEngine

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

@@ -18,19 +18,18 @@
 package org.apache.shardingsphere.core.merge.dal;
 
 import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.core.constant.ShardingConstant;
 import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergeEngine;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.dal.desc.DescribeTableMergedResult;
+import org.apache.shardingsphere.core.merge.dal.common.SingleLocalDataMergedResult;
+import org.apache.shardingsphere.core.merge.dal.common.TransparentMergedResult;
 import org.apache.shardingsphere.core.merge.dal.show.LogicTablesMergedResult;
 import org.apache.shardingsphere.core.merge.dal.show.ShowCreateTableMergedResult;
-import org.apache.shardingsphere.core.merge.dal.show.ShowDatabasesMergedResult;
-import org.apache.shardingsphere.core.merge.dal.show.ShowOtherMergedResult;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
 import org.apache.shardingsphere.core.rule.ShardingRule;
 import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
 import org.apache.shardingsphere.sql.parser.sql.statement.SQLStatement;
-import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.DescribeStatement;
 import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.ShowCreateTableStatement;
 import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.ShowDatabasesStatement;
 import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.ShowIndexStatement;
@@ -38,6 +37,7 @@ import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.Show
 import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.ShowTablesStatement;
 
 import java.sql.SQLException;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -61,7 +61,7 @@ public final class DALMergeEngine implements MergeEngine {
     public MergedResult merge() throws SQLException {
         SQLStatement dalStatement = sqlStatementContext.getSqlStatement();
         if (dalStatement instanceof ShowDatabasesStatement) {
-            return new ShowDatabasesMergedResult(queryResults);
+            return new SingleLocalDataMergedResult(Collections.<Object>singletonList(ShardingConstant.LOGIC_SCHEMA_NAME));
         }
         if (dalStatement instanceof ShowTablesStatement || dalStatement instanceof ShowTableStatusStatement || dalStatement instanceof ShowIndexStatement) {
             return new LogicTablesMergedResult(shardingRule, sqlStatementContext, tableMetas, queryResults);
@@ -69,9 +69,6 @@ public final class DALMergeEngine implements MergeEngine {
         if (dalStatement instanceof ShowCreateTableStatement) {
             return new ShowCreateTableMergedResult(shardingRule, sqlStatementContext, tableMetas, queryResults);
         }
-        if (dalStatement instanceof DescribeStatement) {
-            return new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
-        }
-        return new ShowOtherMergedResult(queryResults.get(0));
+        return new TransparentMergedResult(queryResults.get(0));
     }
 }

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/show/ShowDatabasesMergedResult.java → sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/common/MultipleLocalDataMergedResult.java

@@ -15,67 +15,59 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge.dal.show;
+package org.apache.shardingsphere.core.merge.dal.common;
 
-import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergedResult;
 
 import java.io.InputStream;
-import java.io.Reader;
-import java.sql.Blob;
-import java.sql.Clob;
 import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
-import java.sql.SQLXML;
+import java.util.Calendar;
 import java.util.Collection;
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
 
 /**
- * Merged result for show databases.
+ * Merged result for multiple local data.
  *
- * @author chenqingyang
- * @author xiayan
+ * @author zhangliang
  */
-public final class ShowDatabasesMergedResult extends LocalMergedResultAdapter implements MergedResult {
+public final class MultipleLocalDataMergedResult implements MergedResult {
     
-    private final Iterator<String> schemas;
+    private final Iterator<List<Object>> rows;
     
-    private String currentSchema;
+    private List<Object> currentRow;
     
-    public ShowDatabasesMergedResult(final Collection<String> schemas) {
-        this.schemas = schemas.iterator();
-    }
-    
-    public ShowDatabasesMergedResult(final List<QueryResult> queryResults)throws SQLException {
-        this(convertToScheme(queryResults));
-    }
-    
-    private static Collection<String> convertToScheme(final List<QueryResult> queryResults) throws SQLException {
-        Collection<String> result = new LinkedList<>();
-        for (QueryResult queryResult : queryResults) {
-            while (queryResult.next()) {
-                result.add((String) queryResult.getValue(1, String.class));
-            }
-        }
-        return result;
+    public MultipleLocalDataMergedResult(final Collection<List<Object>> rows) {
+        this.rows = rows.iterator();
     }
     
     @Override
     public boolean next() {
-        if (schemas.hasNext()) {
-            currentSchema = schemas.next();
+        if (rows.hasNext()) {
+            currentRow = rows.next();
             return true;
         }
         return false;
     }
     
     @Override
-    public Object getValue(final int columnIndex, final Class<?> type) throws SQLException {
-        if (Blob.class == type || Clob.class == type || Reader.class == type || InputStream.class == type || SQLXML.class == type) {
-            throw new SQLFeatureNotSupportedException();
-        }
-        return currentSchema;
+    public Object getValue(final int columnIndex, final Class<?> type) {
+        return currentRow.get(columnIndex - 1);
+    }
+    
+    @Override
+    public Object getCalendarValue(final int columnIndex, final Class<?> type, final Calendar calendar) {
+        return currentRow.get(columnIndex - 1);
+    }
+    
+    @Override
+    public InputStream getInputStream(final int columnIndex, final String type) throws SQLException {
+        throw new SQLFeatureNotSupportedException();
+    }
+    
+    @Override
+    public boolean wasNull() {
+        return null == currentRow;
     }
 }

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/show/LocalMergedResultAdapter.java → sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/common/SingleLocalDataMergedResult.java

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge.dal.show;
+package org.apache.shardingsphere.core.merge.dal.common;
 
 import org.apache.shardingsphere.core.merge.MergedResult;
 
@@ -23,26 +23,50 @@ import java.io.InputStream;
 import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
 import java.util.Calendar;
+import java.util.Collection;
+import java.util.Iterator;
 
 /**
- * Show local merged result adapter.
+ * Merged result for single local data.
  *
- * @author zhaojun
+ * @author zhangliang
  */
-public abstract class LocalMergedResultAdapter implements MergedResult {
+public final class SingleLocalDataMergedResult implements MergedResult {
+    
+    private final Iterator<Object> values;
+    
+    private Object currentValue;
+    
+    public SingleLocalDataMergedResult(final Collection<Object> values) {
+        this.values = values.iterator();
+    }
     
     @Override
-    public final Object getCalendarValue(final int columnIndex, final Class<?> type, final Calendar calendar) throws SQLException {
-        throw new SQLFeatureNotSupportedException();
+    public boolean next() {
+        if (values.hasNext()) {
+            currentValue = values.next();
+            return true;
+        }
+        return false;
     }
     
     @Override
-    public final InputStream getInputStream(final int columnIndex, final String type) throws SQLException {
+    public Object getValue(final int columnIndex, final Class<?> type) {
+        return currentValue;
+    }
+    
+    @Override
+    public Object getCalendarValue(final int columnIndex, final Class<?> type, final Calendar calendar) {
+        return currentValue;
+    }
+    
+    @Override
+    public InputStream getInputStream(final int columnIndex, final String type) throws SQLException {
         throw new SQLFeatureNotSupportedException();
     }
     
     @Override
-    public final boolean wasNull() {
-        return false;
+    public boolean wasNull() {
+        return null == currentValue;
     }
 }

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/show/ShowOtherMergedResult.java → sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/common/TransparentMergedResult.java

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge.dal.show;
+package org.apache.shardingsphere.core.merge.dal.common;
 
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
@@ -23,16 +23,15 @@ import org.apache.shardingsphere.core.merge.MergedResult;
 
 import java.io.InputStream;
 import java.sql.SQLException;
-import java.sql.SQLFeatureNotSupportedException;
 import java.util.Calendar;
 
 /**
- * Merged result for show others.
+ * Transparent merged result.
  *
  * @author zhangliang
  */
 @RequiredArgsConstructor
-public final class ShowOtherMergedResult implements MergedResult {
+public final class TransparentMergedResult implements MergedResult {
     
     private final QueryResult queryResult;
     
@@ -48,16 +47,16 @@ public final class ShowOtherMergedResult implements MergedResult {
     
     @Override
     public Object getCalendarValue(final int columnIndex, final Class<?> type, final Calendar calendar) throws SQLException {
-        throw new SQLFeatureNotSupportedException();
+        return queryResult.getCalendarValue(columnIndex, type, calendar);
     }
     
     @Override
     public InputStream getInputStream(final int columnIndex, final String type) throws SQLException {
-        throw new SQLFeatureNotSupportedException();
+        return queryResult.getInputStream(columnIndex, type);
     }
     
     @Override
-    public boolean wasNull() {
-        return false;
+    public boolean wasNull() throws SQLException {
+        return queryResult.wasNull();
     }
 }

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

@@ -37,7 +37,7 @@ import java.util.Set;
  *
  * @author zhangliang
  */
-public class LogicTablesMergedResult extends MemoryMergedResult {
+public class LogicTablesMergedResult extends MemoryMergedResult<ShardingRule> {
     
     public LogicTablesMergedResult(final ShardingRule shardingRule, 
                                    final SQLStatementContext sqlStatementContext, final TableMetas tableMetas, final List<QueryResult> queryResults) throws SQLException {

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

-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.core.merge.dal.show;
-
-import lombok.RequiredArgsConstructor;
-import org.apache.shardingsphere.core.merge.MergedResult;
-
-import java.util.List;
-
-/**
- * Show sharding CTL merged result.
- *
- * @author zhaojun
- * @author liya
- */
-@RequiredArgsConstructor
-public final class ShowShardingCTLMergedResult extends LocalMergedResultAdapter implements MergedResult {
-    
-    private int currentIndex;
-    
-    private final List<List<Object>> values;
-    
-    @Override
-    public boolean next() {
-        return currentIndex++ < values.size();
-    }
-    
-    @Override
-    public Object getValue(final int columnIndex, final Class<?> type) {
-        return values.get(currentIndex - 1).get(columnIndex - 1);
-    }
-}

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

@@ -21,7 +21,7 @@ import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.merge.MergedResult;
 import org.apache.shardingsphere.core.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.rule.ShardingRule;
+import org.apache.shardingsphere.core.rule.BaseRule;
 import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
 
 import java.io.InputStream;
@@ -39,9 +39,11 @@ import java.util.List;
  * Memory merged result.
  *
  * @author zhangliang
+ * 
+ * @param <T> type of rule
  */
 @RequiredArgsConstructor
-public abstract class MemoryMergedResult implements MergedResult {
+public abstract class MemoryMergedResult<T extends BaseRule> implements MergedResult {
     
     private final Iterator<MemoryQueryResultRow> memoryResultSetRows;
     
@@ -49,17 +51,15 @@ public abstract class MemoryMergedResult implements MergedResult {
     
     private boolean wasNull;
     
-    protected MemoryMergedResult(final ShardingRule shardingRule, 
-                                 final TableMetas tableMetas, final SQLStatementContext sqlStatementContext, final List<QueryResult> queryResults) throws SQLException {
-        List<MemoryQueryResultRow> memoryQueryResultRowList = init(shardingRule, tableMetas, sqlStatementContext, queryResults);
+    protected MemoryMergedResult(final T rule, final TableMetas tableMetas, final SQLStatementContext sqlStatementContext, final List<QueryResult> queryResults) throws SQLException {
+        List<MemoryQueryResultRow> memoryQueryResultRowList = init(rule, tableMetas, sqlStatementContext, queryResults);
         memoryResultSetRows = memoryQueryResultRowList.iterator();
         if (!memoryQueryResultRowList.isEmpty()) {
             currentResultSetRow = memoryQueryResultRowList.get(0);
         }
     }
     
-    protected abstract List<MemoryQueryResultRow> init(ShardingRule shardingRule, TableMetas tableMetas, 
-                                                       SQLStatementContext sqlStatementContext, List<QueryResult> queryResults) throws SQLException;
+    protected abstract List<MemoryQueryResultRow> init(T rule, TableMetas tableMetas, SQLStatementContext sqlStatementContext, List<QueryResult> queryResults) throws SQLException;
     
     @Override
     public final boolean next() {

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

@@ -47,7 +47,7 @@ import java.util.Map.Entry;
  * @author zhangliang
  * @author yangyi
  */
-public final class GroupByMemoryMergedResult extends MemoryMergedResult {
+public final class GroupByMemoryMergedResult extends MemoryMergedResult<ShardingRule> {
     
     public GroupByMemoryMergedResult(final List<QueryResult> queryResults, final SelectSQLStatementContext selectSQLStatementContext) throws SQLException {
         super(null, null, selectSQLStatementContext, queryResults);

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

+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.core.merge.encrypt.dal;
+
+import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
+import org.apache.shardingsphere.core.merge.MergeEngine;
+import org.apache.shardingsphere.core.merge.MergedResult;
+import org.apache.shardingsphere.core.merge.dal.common.TransparentMergedResult;
+import org.apache.shardingsphere.core.rule.EncryptRule;
+import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
+import org.apache.shardingsphere.sql.parser.sql.statement.SQLStatement;
+import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.DescribeStatement;
+
+import java.sql.SQLException;
+import java.util.List;
+
+/**
+ * DAL result set merge engine for encrypt.
+ *
+ * @author zhangliang
+ */
+@RequiredArgsConstructor
+public final class DALEncryptMergeEngine implements MergeEngine {
+    
+    private final EncryptRule encryptRule;
+    
+    private final List<QueryResult> queryResults;
+    
+    private final SQLStatementContext sqlStatementContext;
+    
+    @Override
+    public MergedResult merge() throws SQLException {
+        SQLStatement dalStatement = sqlStatementContext.getSqlStatement();
+        if (dalStatement instanceof DescribeStatement) {
+            return new DescribeTableMergedResult(encryptRule, queryResults, sqlStatementContext);
+        }
+        return new TransparentMergedResult(queryResults.get(0));
+    }
+}

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

@@ -15,14 +15,14 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge.dal.desc;
+package org.apache.shardingsphere.core.merge.encrypt.dal;
 
 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.metadata.table.TableMetas;
-import org.apache.shardingsphere.core.rule.ShardingRule;
+import org.apache.shardingsphere.core.rule.EncryptRule;
 import org.apache.shardingsphere.core.strategy.encrypt.EncryptTable;
 import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
 
@@ -35,19 +35,19 @@ import java.util.List;
  *
  * @author liya
  */
-public final class DescribeTableMergedResult extends MemoryMergedResult {
+public final class DescribeTableMergedResult extends MemoryMergedResult<EncryptRule> {
     
-    public DescribeTableMergedResult(final ShardingRule shardingRule, final List<QueryResult> queryResults, final SQLStatementContext sqlStatementContext) throws SQLException {
-        super(shardingRule, null, sqlStatementContext, queryResults);
+    public DescribeTableMergedResult(final EncryptRule encryptRule, final List<QueryResult> queryResults, final SQLStatementContext sqlStatementContext) throws SQLException {
+        super(encryptRule, null, sqlStatementContext, queryResults);
     }
     
     @Override
-    protected List<MemoryQueryResultRow> init(final ShardingRule shardingRule, final TableMetas tableMetas, 
+    protected List<MemoryQueryResultRow> init(final EncryptRule encryptRule, final TableMetas tableMetas, 
                                               final SQLStatementContext sqlStatementContext, final List<QueryResult> queryResults) throws SQLException {
         List<MemoryQueryResultRow> result = new LinkedList<>();
         for (QueryResult each : queryResults) {
             while (each.next()) {
-                Optional<MemoryQueryResultRow> memoryQueryResultRow = optimize(shardingRule, sqlStatementContext, each);
+                Optional<MemoryQueryResultRow> memoryQueryResultRow = optimize(encryptRule, sqlStatementContext, each);
                 if (memoryQueryResultRow.isPresent()) {
                     result.add(memoryQueryResultRow.get());
                 }
@@ -56,10 +56,9 @@ public final class DescribeTableMergedResult extends MemoryMergedResult {
         return result;
     }
     
-    private Optional<MemoryQueryResultRow> optimize(final ShardingRule shardingRule, final SQLStatementContext sqlStatementContext, final QueryResult queryResult) throws SQLException {
+    private Optional<MemoryQueryResultRow> optimize(final EncryptRule encryptRule, final SQLStatementContext sqlStatementContext, final QueryResult queryResult) throws SQLException {
         MemoryQueryResultRow memoryQueryResultRow = new MemoryQueryResultRow(queryResult);
-        Optional<EncryptTable> encryptTable = null == shardingRule.getEncryptRule()
-                ? Optional.<EncryptTable>absent() : shardingRule.getEncryptRule().findEncryptTable(sqlStatementContext.getTablesContext().getSingleTableName());
+        Optional<EncryptTable> encryptTable = encryptRule.findEncryptTable(sqlStatementContext.getTablesContext().getSingleTableName());
         if (encryptTable.isPresent()) {
             String columnName = memoryQueryResultRow.getCell(1).toString();
             if (encryptTable.get().getAssistedQueryColumns().contains(columnName) || encryptTable.get().getPlainColumns().contains(columnName)) {

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/encrypt/EncryptMergeEngine.java → sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/encrypt/dql/DQLEncryptMergeEngine.java

@@ -15,22 +15,21 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge.encrypt;
+package org.apache.shardingsphere.core.merge.encrypt.dql;
 
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.core.merge.MergeEngine;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.MergedResultMetaData;
 
 /**
- * Encrypt result set merge engine.
+ * DQL result set merge engine for encrypt.
  *
  * @author zhangliang
  */
 @RequiredArgsConstructor
-public final class EncryptMergeEngine implements MergeEngine {
+public final class DQLEncryptMergeEngine implements MergeEngine {
     
-    private final MergedResultMetaData metaData;
+    private final EncryptorMetaData metaData;
     
     private final MergedResult mergedResult;
     

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/encrypt/EncryptMergedResult.java → sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/encrypt/dql/EncryptMergedResult.java

@@ -15,12 +15,11 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge.encrypt;
+package org.apache.shardingsphere.core.merge.encrypt.dql;
 
 import com.google.common.base.Optional;
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.MergedResultMetaData;
 import org.apache.shardingsphere.spi.encrypt.ShardingEncryptor;
 
 import java.io.InputStream;
@@ -35,7 +34,7 @@ import java.util.Calendar;
 @RequiredArgsConstructor
 public final class EncryptMergedResult implements MergedResult {
     
-    private final MergedResultMetaData metaData;
+    private final EncryptorMetaData metaData;
     
     private final MergedResult mergedResult;
     

sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/MergedResultMetaData.java → sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/encrypt/dql/EncryptorMetaData.java

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge;
+package org.apache.shardingsphere.core.merge.encrypt.dql;
 
 import com.google.common.base.Optional;
 import org.apache.shardingsphere.spi.encrypt.ShardingEncryptor;
@@ -23,11 +23,11 @@ import org.apache.shardingsphere.spi.encrypt.ShardingEncryptor;
 import java.sql.SQLException;
 
 /**
- * Merged result meta data.
+ * Encryptor meta data.
  *
  * @author zhangliang
  */
-public interface MergedResultMetaData {
+public interface EncryptorMetaData {
     
     /**
      * Find encryptor.

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

@@ -18,11 +18,11 @@
 package org.apache.shardingsphere.core.merge.dal;
 
 import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
-import org.apache.shardingsphere.core.merge.dal.desc.DescribeTableMergedResult;
+import org.apache.shardingsphere.core.merge.dal.common.SingleLocalDataMergedResult;
+import org.apache.shardingsphere.core.merge.dal.common.TransparentMergedResult;
 import org.apache.shardingsphere.core.merge.dal.show.LogicTablesMergedResult;
 import org.apache.shardingsphere.core.merge.dal.show.ShowCreateTableMergedResult;
-import org.apache.shardingsphere.core.merge.dal.show.ShowDatabasesMergedResult;
-import org.apache.shardingsphere.core.merge.dal.show.ShowOtherMergedResult;
+import org.apache.shardingsphere.core.rule.ShardingRule;
 import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
 import org.apache.shardingsphere.sql.parser.sql.statement.dal.DALStatement;
 import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.DescribeStatement;
@@ -56,7 +56,7 @@ public final class DALMergeEngineTest {
         DALStatement dalStatement = new ShowDatabasesStatement();
         SQLStatementContext sqlStatementContext = mockSQLStatementContext(dalStatement);
         DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, sqlStatementContext, null);
-        assertThat(dalMergeEngine.merge(), instanceOf(ShowDatabasesMergedResult.class));
+        assertThat(dalMergeEngine.merge(), instanceOf(SingleLocalDataMergedResult.class));
     }
     
     @Test
@@ -80,15 +80,15 @@ public final class DALMergeEngineTest {
         DALStatement dalStatement = new ShowOtherStatement();
         SQLStatementContext sqlStatementContext = mockSQLStatementContext(dalStatement);
         DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, sqlStatementContext, null);
-        assertThat(dalMergeEngine.merge(), instanceOf(ShowOtherMergedResult.class));
+        assertThat(dalMergeEngine.merge(), instanceOf(TransparentMergedResult.class));
     }
     
     @Test
     public void assertMergeForDescribeStatement() throws SQLException {
         DALStatement dalStatement = new DescribeStatement();
         SQLStatementContext sqlStatementContext = mockSQLStatementContext(dalStatement);
-        DALMergeEngine dalMergeEngine = new DALMergeEngine(null, queryResults, sqlStatementContext, null);
-        assertThat(dalMergeEngine.merge(), instanceOf(DescribeTableMergedResult.class));
+        DALMergeEngine dalMergeEngine = new DALMergeEngine(mock(ShardingRule.class), queryResults, sqlStatementContext, null);
+        assertThat(dalMergeEngine.merge(), instanceOf(TransparentMergedResult.class));
     }
     
     private SQLStatementContext mockSQLStatementContext(final DALStatement dalStatement) {

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/show/ShowDatabasesMergedResultTest.java → sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/common/MultipleLocalDataMergedResultTest.java

@@ -15,107 +15,60 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge.dal.show;
+package org.apache.shardingsphere.core.merge.dal.common;
 
-import org.apache.shardingsphere.core.constant.ShardingConstant;
-import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
-import org.junit.Before;
 import org.junit.Test;
 
 import java.sql.SQLException;
 import java.sql.SQLFeatureNotSupportedException;
-import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Collections;
+import java.util.Date;
+import java.util.List;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
 
-public final class ShowDatabasesMergedResultTest {
-    
-    private ShowDatabasesMergedResult showDatabasesMergedResult;
-    
-    @Before
-    public void setUp() {
-        showDatabasesMergedResult = new ShowDatabasesMergedResult(Collections.singletonList(ShardingConstant.LOGIC_SCHEMA_NAME));
-    }
+public final class MultipleLocalDataMergedResultTest {
     
     @Test
     public void assertNext() {
-        assertTrue(showDatabasesMergedResult.next());
-        assertFalse(showDatabasesMergedResult.next());
+        List<Object> row = Collections.<Object>singletonList("value");
+        MultipleLocalDataMergedResult actual = new MultipleLocalDataMergedResult(Collections.singletonList(row));
+        assertTrue(actual.next());
+        assertFalse(actual.next());
     }
     
     @Test
-    public void assertGetValueWithColumnIndex() throws SQLException {
-        assertTrue(showDatabasesMergedResult.next());
-        assertThat(showDatabasesMergedResult.getValue(1, Object.class).toString(), is(ShardingConstant.LOGIC_SCHEMA_NAME));
+    public void assertGetValue() {
+        List<Object> row = Collections.<Object>singletonList("value");
+        MultipleLocalDataMergedResult actual = new MultipleLocalDataMergedResult(Collections.singletonList(row));
+        assertTrue(actual.next());
+        assertThat(actual.getValue(1, Object.class).toString(), is("value"));
     }
     
-    @Test(expected = SQLFeatureNotSupportedException.class)
-    public void assertGetCalendarValueWithColumnIndex() throws SQLException {
-        showDatabasesMergedResult.getCalendarValue(1, Object.class, Calendar.getInstance());
+    @Test
+    public void assertGetCalendarValue() {
+        List<Object> row = Collections.<Object>singletonList(new Date(0L));
+        MultipleLocalDataMergedResult actual = new MultipleLocalDataMergedResult(Collections.singletonList(row));
+        assertTrue(actual.next());
+        assertThat(actual.getCalendarValue(1, Object.class, Calendar.getInstance()), is((Object) new Date(0L)));
     }
     
     @Test(expected = SQLFeatureNotSupportedException.class)
-    public void assertGetInputStreamWithColumnIndex() throws SQLException {
-        showDatabasesMergedResult.getInputStream(1, "Ascii");
+    public void assertGetInputStream() throws SQLException {
+        List<Object> row = Collections.<Object>singletonList("value");
+        MultipleLocalDataMergedResult actual = new MultipleLocalDataMergedResult(Collections.singletonList(row));
+        actual.getInputStream(1, "Ascii");
     }
     
     @Test
     public void assertWasNull() {
-        assertFalse(showDatabasesMergedResult.wasNull());
-    }
-
-    @Test
-    public void assertMergeNext() throws SQLException {
-        ShowDatabasesMergedResult actual = buildMergedShowDatabasesMergedResult();
-        assertTrue(actual.next());
+        List<Object> row = Collections.<Object>singletonList("value");
+        MultipleLocalDataMergedResult actual = new MultipleLocalDataMergedResult(Collections.singletonList(row));
         assertTrue(actual.next());
-        assertTrue(actual.next());
-        assertTrue(actual.next());
-        assertTrue(actual.next());
-        assertFalse(actual.next());
-    }
-
-    @Test
-    public void assertSchemes() throws SQLException {
-        ShowDatabasesMergedResult actual = buildMergedShowDatabasesMergedResult();
-        actual.next();
-        assertThat(actual.getValue(1, String.class).toString(), is("A"));
-        actual.next();
-        assertThat(actual.getValue(1, String.class).toString(), is("B"));
-        actual.next();
-        assertThat(actual.getValue(1, String.class).toString(), is("C"));
-        actual.next();
-        assertThat(actual.getValue(1, String.class).toString(), is("D"));
-        actual.next();
-        assertThat(actual.getValue(1, String.class).toString(), is("E"));
-    }
-
-    private ShowDatabasesMergedResult buildMergedShowDatabasesMergedResult() throws SQLException {
-        return new ShowDatabasesMergedResult(Arrays.asList(createQueryResult1(), createQueryResult2()));
-    }
-    
-    private QueryResult createQueryResult1() throws SQLException {
-        QueryResult result = mock(QueryResult.class);
-        when(result.next()).thenReturn(true, true, true, false);
-        when(result.getValue(1, String.class)).thenReturn("A", "B", "C");
-        when(result.getColumnCount()).thenReturn(1);
-        when(result.getColumnLabel(1)).thenReturn("SCHEMA_NAME");
-        return result;
-    }
-    
-    private QueryResult createQueryResult2() throws SQLException {
-        QueryResult result = mock(QueryResult.class);
-        when(result.next()).thenReturn(true, true, false);
-        when(result.getValue(1, String.class)).thenReturn("D", "E");
-        when(result.getColumnCount()).thenReturn(1);
-        when(result.getColumnLabel(1)).thenReturn("SCHEMA_NAME");
-        return result;
+        assertFalse(actual.wasNull());
     }
 }

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

+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.core.merge.dal.common;
+
+import org.junit.Test;
+
+import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+public final class SingleLocalDataMergedResultTest {
+    
+    @Test
+    public void assertNext() {
+        SingleLocalDataMergedResult actual = new SingleLocalDataMergedResult(Collections.<Object>singleton("value"));
+        assertTrue(actual.next());
+        assertFalse(actual.next());
+    }
+    
+    @Test
+    public void assertGetValue() {
+        SingleLocalDataMergedResult actual = new SingleLocalDataMergedResult(Collections.<Object>singleton("value"));
+        assertTrue(actual.next());
+        assertThat(actual.getValue(1, Object.class).toString(), is("value"));
+    }
+    
+    @Test
+    public void assertGetCalendarValue() {
+        SingleLocalDataMergedResult actual = new SingleLocalDataMergedResult(Collections.<Object>singleton(new Date(0L)));
+        assertTrue(actual.next());
+        assertThat(actual.getCalendarValue(1, Object.class, Calendar.getInstance()), is((Object) new Date(0L)));
+    }
+    
+    @Test(expected = SQLFeatureNotSupportedException.class)
+    public void assertGetInputStream() throws SQLException {
+        SingleLocalDataMergedResult actual = new SingleLocalDataMergedResult(Collections.<Object>singleton("value"));
+        actual.getInputStream(1, "Ascii");
+    }
+    
+    @Test
+    public void assertWasNull() {
+        SingleLocalDataMergedResult actual = new SingleLocalDataMergedResult(Collections.<Object>singleton("value"));
+        assertTrue(actual.next());
+        assertFalse(actual.wasNull());
+    }
+}

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/show/ShowOtherMergedResultTest.java → sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/common/TransparentMergedResultTest.java

@@ -15,17 +15,17 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge.dal.show;
+package org.apache.shardingsphere.core.merge.dal.common;
 
 import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
+import org.hamcrest.CoreMatchers;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.junit.MockitoJUnitRunner;
 
+import java.io.InputStream;
 import java.sql.Date;
 import java.sql.SQLException;
-import java.sql.SQLFeatureNotSupportedException;
-import java.util.Calendar;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertFalse;
@@ -35,13 +35,13 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
-public final class ShowOtherMergedResultTest {
+public final class TransparentMergedResultTest {
     
     @Test
     public void assertNext() throws SQLException {
         QueryResult queryResult = mock(QueryResult.class);
         when(queryResult.next()).thenReturn(true, false);
-        ShowOtherMergedResult actual = new ShowOtherMergedResult(queryResult);
+        TransparentMergedResult actual = new TransparentMergedResult(queryResult);
         assertTrue(actual.next());
         assertFalse(actual.next());
     }
@@ -50,25 +50,30 @@ public final class ShowOtherMergedResultTest {
     public void assertGetValue() throws SQLException {
         QueryResult queryResult = mock(QueryResult.class);
         when(queryResult.getValue(1, Object.class)).thenReturn("1");
-        ShowOtherMergedResult actual = new ShowOtherMergedResult(queryResult);
+        TransparentMergedResult actual = new TransparentMergedResult(queryResult);
         assertThat(actual.getValue(1, Object.class).toString(), is("1"));
     }
     
-    @Test(expected = SQLFeatureNotSupportedException.class)
+    @Test
     public void assertGetCalendarValue() throws SQLException {
-        ShowOtherMergedResult actual = new ShowOtherMergedResult(mock(QueryResult.class));
-        actual.getCalendarValue(1, Date.class, Calendar.getInstance());
+        QueryResult queryResult = mock(QueryResult.class);
+        when(queryResult.getCalendarValue(1, Date.class, null)).thenReturn(new Date(0L));
+        TransparentMergedResult actual = new TransparentMergedResult(queryResult);
+        assertThat(actual.getCalendarValue(1, Date.class, null), CoreMatchers.<Object>is(new Date(0L)));
     }
     
-    @Test(expected = SQLFeatureNotSupportedException.class)
+    @Test
     public void assertGetInputStream() throws SQLException {
-        ShowOtherMergedResult actual = new ShowOtherMergedResult(mock(QueryResult.class));
-        actual.getInputStream(1, "Ascii");
+        QueryResult queryResult = mock(QueryResult.class);
+        InputStream value = mock(InputStream.class);
+        when(queryResult.getInputStream(1, "Ascii")).thenReturn(value);
+        TransparentMergedResult actual = new TransparentMergedResult(queryResult);
+        assertThat(actual.getInputStream(1, "Ascii"), is(value));
     }
     
     @Test
-    public void assertWasNull() {
-        ShowOtherMergedResult actual = new ShowOtherMergedResult(mock(QueryResult.class));
+    public void assertWasNull() throws SQLException {
+        TransparentMergedResult actual = new TransparentMergedResult(mock(QueryResult.class));
         assertFalse(actual.wasNull());
     }
 }

sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/common/fixture/TestMemoryMergedResult.java

@@ -32,7 +32,7 @@ import java.util.List;
 import static org.mockito.Mockito.mock;
 
 @Getter
-public final class TestMemoryMergedResult extends MemoryMergedResult {
+public final class TestMemoryMergedResult extends MemoryMergedResult<ShardingRule> {
     
     private MemoryQueryResultRow memoryQueryResultRow;
     
@@ -42,7 +42,7 @@ public final class TestMemoryMergedResult extends MemoryMergedResult {
     
     @Override
     protected List<MemoryQueryResultRow> init(final ShardingRule shardingRule, final TableMetas tableMetas, 
-                                                    final SQLStatementContext sqlStatementContext, final List<QueryResult> queryResults) {
+                                              final SQLStatementContext sqlStatementContext, final List<QueryResult> queryResults) {
         memoryQueryResultRow = mock(MemoryQueryResultRow.class);
         return Collections.singletonList(memoryQueryResultRow);
     }

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

@@ -15,12 +15,11 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.core.merge.dal.desc;
+package org.apache.shardingsphere.core.merge.encrypt.dal;
 
 import com.google.common.base.Optional;
 import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
 import org.apache.shardingsphere.core.rule.EncryptRule;
-import org.apache.shardingsphere.core.rule.ShardingRule;
 import org.apache.shardingsphere.core.strategy.encrypt.EncryptTable;
 import org.apache.shardingsphere.sql.parser.relation.segment.table.TablesContext;
 import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
@@ -40,15 +39,15 @@ public final class DescribeTableMergedResultTest {
     
     @Test
     public void assertNextForEmptyQueryResult() throws SQLException {
-        ShardingRule shardingRule = mock(ShardingRule.class);
-        DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.<QueryResult>emptyList(), createSQLStatementContext());
+        EncryptRule encryptRule = mock(EncryptRule.class);
+        DescribeTableMergedResult actual = new DescribeTableMergedResult(encryptRule, Collections.<QueryResult>emptyList(), createSQLStatementContext());
         assertFalse(actual.next());
     }
     
     @Test
     public void assertFieldWithEncryptRule() throws SQLException {
-        ShardingRule shardingRule = createShardingRuleWithEncryptRule();
-        DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
+        EncryptRule encryptRule = createEncryptRule();
+        DescribeTableMergedResult actual = new DescribeTableMergedResult(encryptRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
         assertTrue(actual.next());
         assertThat(actual.getValue(1, String.class).toString(), is("id"));
         assertTrue(actual.next());
@@ -58,40 +57,10 @@ public final class DescribeTableMergedResultTest {
         assertFalse(actual.next());
     }
     
-    @Test
-    public void assertFieldWithoutEncryptRule() throws SQLException {
-        ShardingRule shardingRule = mock(ShardingRule.class);
-        DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
-        assertTrue(actual.next());
-        assertThat(actual.getValue(1, String.class).toString(), is("id"));
-        assertTrue(actual.next());
-        assertThat(actual.getValue(1, String.class).toString(), is("name"));
-        assertTrue(actual.next());
-        assertThat(actual.getValue(1, String.class).toString(), is("pre_name"));
-        assertTrue(actual.next());
-        assertThat(actual.getValue(1, String.class).toString(), is("name_assisted"));
-        assertTrue(actual.next());
-        assertThat(actual.getValue(1, String.class).toString(), is("name_plain"));
-        assertFalse(actual.next());
-    }
-    
-    @Test
-    public void assertAllWithoutEncryptRule() throws SQLException {
-        ShardingRule shardingRule = mock(ShardingRule.class);
-        DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
-        assertTrue(actual.next());
-        assertThat(actual.getValue(1, String.class).toString(), is("id"));
-        assertThat(actual.getValue(2, String.class).toString(), is("int(11) unsigned"));
-        assertThat(actual.getValue(3, String.class).toString(), is("NO"));
-        assertThat(actual.getValue(4, String.class).toString(), is("PRI"));
-        assertThat(actual.getValue(5, String.class).toString(), is(""));
-        assertThat(actual.getValue(6, String.class).toString(), is("auto_increment"));
-    }
-    
     @Test
     public void assertAllWithEncryptRule() throws SQLException {
-        ShardingRule shardingRule = createShardingRuleWithEncryptRule();
-        DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
+        EncryptRule encryptRule = createEncryptRule();
+        DescribeTableMergedResult actual = new DescribeTableMergedResult(encryptRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
         assertTrue(actual.next());
         assertThat(actual.getValue(1, String.class).toString(), is("id"));
         assertThat(actual.getValue(2, String.class).toString(), is("int(11) unsigned"));
@@ -101,12 +70,10 @@ public final class DescribeTableMergedResultTest {
         assertThat(actual.getValue(6, String.class).toString(), is("auto_increment"));
     }
     
-    private ShardingRule createShardingRuleWithEncryptRule() {
-        ShardingRule result = mock(ShardingRule.class);
-        EncryptRule encryptRule = mock(EncryptRule.class);
+    private EncryptRule createEncryptRule() {
+        EncryptRule result = mock(EncryptRule.class);
         EncryptTable encryptTable = mock(EncryptTable.class);
-        when(result.getEncryptRule()).thenReturn(encryptRule);
-        when(encryptRule.findEncryptTable("user")).thenReturn(Optional.of(encryptTable));
+        when(result.findEncryptTable("user")).thenReturn(Optional.of(encryptTable));
         when(encryptTable.getAssistedQueryColumns()).thenReturn(Collections.singletonList("name_assisted"));
         when(encryptTable.getPlainColumns()).thenReturn(Collections.singletonList("name_plain"));
         when(encryptTable.getCipherColumns()).thenReturn(Collections.singletonList("name"));

sharding-jdbc/sharding-jdbc-core/src/main/java/org/apache/shardingsphere/shardingjdbc/jdbc/core/statement/ResultSetMergedResultMetaData.java → sharding-jdbc/sharding-jdbc-core/src/main/java/org/apache/shardingsphere/shardingjdbc/jdbc/core/statement/ResultSetEncryptorMetaData.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.shardingjdbc.jdbc.core.statement;
 
 import com.google.common.base.Optional;
 import lombok.RequiredArgsConstructor;
-import org.apache.shardingsphere.core.merge.MergedResultMetaData;
+import org.apache.shardingsphere.core.merge.encrypt.dql.EncryptorMetaData;
 import org.apache.shardingsphere.core.rule.EncryptRule;
 import org.apache.shardingsphere.spi.encrypt.ShardingEncryptor;
 import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
@@ -28,12 +28,12 @@ import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 
 /**
- * Merged result meta data for query header.
+ * Encryptor meta data for query header.
  *
  * @author zhangliang
  */
 @RequiredArgsConstructor
-public final class ResultSetMergedResultMetaData implements MergedResultMetaData {
+public final class ResultSetEncryptorMetaData implements EncryptorMetaData {
     
     private final EncryptRule encryptRule;
     

sharding-jdbc/sharding-jdbc-core/src/main/java/org/apache/shardingsphere/shardingjdbc/jdbc/core/statement/ShardingPreparedStatement.java

@@ -30,9 +30,11 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.StreamQueryResu
 import org.apache.shardingsphere.core.merge.MergeEngine;
 import org.apache.shardingsphere.core.merge.MergeEngineFactory;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.encrypt.EncryptMergeEngine;
+import org.apache.shardingsphere.core.merge.encrypt.dal.DALEncryptMergeEngine;
+import org.apache.shardingsphere.core.merge.encrypt.dql.DQLEncryptMergeEngine;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
 import org.apache.shardingsphere.core.route.router.sharding.keygen.GeneratedKey;
+import org.apache.shardingsphere.core.rule.EncryptRule;
 import org.apache.shardingsphere.shardingjdbc.executor.BatchPreparedStatementExecutor;
 import org.apache.shardingsphere.shardingjdbc.executor.PreparedStatementExecutor;
 import org.apache.shardingsphere.shardingjdbc.jdbc.adapter.AbstractShardingPreparedStatementAdapter;
@@ -51,6 +53,7 @@ import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -153,11 +156,19 @@ public final class ShardingPreparedStatement extends AbstractShardingPreparedSta
     }
     
     private ShardingResultSet getCurrentResultSet(final List<ResultSet> resultSets, final MergeEngine mergeEngine) throws SQLException {
+        EncryptRule encryptRule = connection.getRuntimeContext().getRule().getEncryptRule();
+        if (null != encryptRule && sqlRouteResult.getSqlStatementContext().getSqlStatement() instanceof DALStatement) {
+            MergedResult mergedResult = new DALEncryptMergeEngine(
+                    encryptRule, Collections.<QueryResult>singletonList(new StreamQueryResult(resultSets.get(0))), sqlRouteResult.getSqlStatementContext()).merge();
+            return new ShardingResultSet(resultSets, mergedResult, this, sqlRouteResult);
+        }
         MergedResult mergedResult = mergeEngine.merge();
-        ResultSetMergedResultMetaData metaData = new ResultSetMergedResultMetaData(
-                connection.getRuntimeContext().getRule().getEncryptRule(), resultSets.get(0).getMetaData(), sqlRouteResult.getSqlStatementContext());
+        if (null == encryptRule) {
+            return new ShardingResultSet(resultSets, mergedResult, this, sqlRouteResult);
+        }
+        ResultSetEncryptorMetaData metaData = new ResultSetEncryptorMetaData(encryptRule, resultSets.get(0).getMetaData(), sqlRouteResult.getSqlStatementContext());
         boolean queryWithCipherColumn = connection.getRuntimeContext().getProps().getValue(ShardingPropertiesConstant.QUERY_WITH_CIPHER_COLUMN);
-        return new ShardingResultSet(resultSets, new EncryptMergeEngine(metaData, mergedResult, queryWithCipherColumn).merge(), this, sqlRouteResult);
+        return new ShardingResultSet(resultSets, new DQLEncryptMergeEngine(metaData, mergedResult, queryWithCipherColumn).merge(), this, sqlRouteResult);
     }
     
     @Override

sharding-jdbc/sharding-jdbc-core/src/main/java/org/apache/shardingsphere/shardingjdbc/jdbc/core/statement/ShardingStatement.java

@@ -28,9 +28,11 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.StreamQueryResu
 import org.apache.shardingsphere.core.merge.MergeEngine;
 import org.apache.shardingsphere.core.merge.MergeEngineFactory;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.encrypt.EncryptMergeEngine;
+import org.apache.shardingsphere.core.merge.encrypt.dal.DALEncryptMergeEngine;
+import org.apache.shardingsphere.core.merge.encrypt.dql.DQLEncryptMergeEngine;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
 import org.apache.shardingsphere.core.route.router.sharding.keygen.GeneratedKey;
+import org.apache.shardingsphere.core.rule.EncryptRule;
 import org.apache.shardingsphere.shardingjdbc.executor.StatementExecutor;
 import org.apache.shardingsphere.shardingjdbc.jdbc.adapter.AbstractStatementAdapter;
 import org.apache.shardingsphere.shardingjdbc.jdbc.core.connection.ShardingConnection;
@@ -133,11 +135,19 @@ public final class ShardingStatement extends AbstractStatementAdapter {
     }
     
     private ShardingResultSet getCurrentResultSet(final List<ResultSet> resultSets, final MergeEngine mergeEngine) throws SQLException {
+        EncryptRule encryptRule = connection.getRuntimeContext().getRule().getEncryptRule();
+        if (null != encryptRule && sqlRouteResult.getSqlStatementContext().getSqlStatement() instanceof DALStatement) {
+            MergedResult mergedResult = new DALEncryptMergeEngine(
+                    encryptRule, Collections.<QueryResult>singletonList(new StreamQueryResult(resultSets.get(0))), sqlRouteResult.getSqlStatementContext()).merge();
+            return new ShardingResultSet(resultSets, mergedResult, this, sqlRouteResult);
+        }
         MergedResult mergedResult = mergeEngine.merge();
-        ResultSetMergedResultMetaData metaData = new ResultSetMergedResultMetaData(
-                connection.getRuntimeContext().getRule().getEncryptRule(), resultSets.get(0).getMetaData(), sqlRouteResult.getSqlStatementContext());
+        if (null == encryptRule) {
+            return new ShardingResultSet(resultSets, mergedResult, this, sqlRouteResult);
+        }
+        ResultSetEncryptorMetaData metaData = new ResultSetEncryptorMetaData(encryptRule, resultSets.get(0).getMetaData(), sqlRouteResult.getSqlStatementContext());
         boolean queryWithCipherColumn = connection.getRuntimeContext().getProps().getValue(ShardingPropertiesConstant.QUERY_WITH_CIPHER_COLUMN);
-        return new ShardingResultSet(resultSets, new EncryptMergeEngine(metaData, mergedResult, queryWithCipherColumn).merge(), this, sqlRouteResult);
+        return new ShardingResultSet(resultSets, new DQLEncryptMergeEngine(metaData, mergedResult, queryWithCipherColumn).merge(), this, sqlRouteResult);
     }
     
     @Override

sharding-proxy/sharding-proxy-backend/src/main/java/org/apache/shardingsphere/shardingproxy/backend/communication/jdbc/JDBCDatabaseCommunicationEngine.java

@@ -22,7 +22,8 @@ import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.core.constant.properties.ShardingPropertiesConstant;
 import org.apache.shardingsphere.core.merge.MergeEngineFactory;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.encrypt.EncryptMergeEngine;
+import org.apache.shardingsphere.core.merge.encrypt.dal.DALEncryptMergeEngine;
+import org.apache.shardingsphere.core.merge.encrypt.dql.DQLEncryptMergeEngine;
 import org.apache.shardingsphere.core.route.SQLRouteResult;
 import org.apache.shardingsphere.core.rule.EncryptRule;
 import org.apache.shardingsphere.shardingproxy.backend.communication.DatabaseCommunicationEngine;
@@ -45,6 +46,7 @@ import org.apache.shardingsphere.spi.encrypt.ShardingEncryptor;
 import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.DerivedColumn;
 import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
 import org.apache.shardingsphere.sql.parser.sql.statement.SQLStatement;
+import org.apache.shardingsphere.sql.parser.sql.statement.dal.DALStatement;
 import org.apache.shardingsphere.sql.parser.sql.statement.ddl.DDLStatement;
 import org.apache.shardingsphere.transaction.core.TransactionType;
 
@@ -111,7 +113,7 @@ public final class JDBCDatabaseCommunicationEngine implements DatabaseCommunicat
             mergeUpdateCount(routeResult);
             return response;
         }
-        setMergedResult(routeResult);
+        this.mergedResult = getMergedResult(routeResult);
         handleColumnsForQueryHeader(routeResult);
         return response;
     }
@@ -126,13 +128,20 @@ public final class JDBCDatabaseCommunicationEngine implements DatabaseCommunicat
         return logicSchema instanceof ShardingSchema && logicSchema.getShardingRule().isAllBroadcastTables(sqlStatementContext.getTablesContext().getTableNames());
     }
     
-    private void setMergedResult(final SQLRouteResult routeResult) throws SQLException {
-        boolean queryWithCipherColumn = ShardingProxyContext.getInstance().getShardingProperties().getValue(ShardingPropertiesConstant.QUERY_WITH_CIPHER_COLUMN);
+    private MergedResult getMergedResult(final SQLRouteResult routeResult) throws SQLException {
+        EncryptRule encryptRule = getEncryptRule();
+        if (null != encryptRule && routeResult.getSqlStatementContext() instanceof DALStatement) {
+            return new DALEncryptMergeEngine(encryptRule, ((QueryResponse) response).getQueryResults(), routeResult.getSqlStatementContext()).merge();
+        }
         MergedResult mergedResult = MergeEngineFactory.newInstance(LogicSchemas.getInstance().getDatabaseType(),
                 logicSchema.getShardingRule(), routeResult, logicSchema.getMetaData().getTables(), ((QueryResponse) response).getQueryResults()).merge();
-        EncryptMergeEngine mergeEngine = new EncryptMergeEngine(
-                new QueryHeaderMergedResultMetaData(getEncryptRule(), ((QueryResponse) response).getQueryHeaders()), mergedResult, queryWithCipherColumn);
-        this.mergedResult = mergeEngine.merge();
+        if (null == encryptRule) {
+            return mergedResult;
+        }
+        boolean queryWithCipherColumn = ShardingProxyContext.getInstance().getShardingProperties().getValue(ShardingPropertiesConstant.QUERY_WITH_CIPHER_COLUMN);
+        DQLEncryptMergeEngine mergeEngine = new DQLEncryptMergeEngine(
+                new QueryHeaderEncryptorMetaData(getEncryptRule(), ((QueryResponse) response).getQueryHeaders()), mergedResult, queryWithCipherColumn);
+        return mergeEngine.merge();
     }
     
     private void handleColumnsForQueryHeader(final SQLRouteResult routeResult) {

sharding-proxy/sharding-proxy-backend/src/main/java/org/apache/shardingsphere/shardingproxy/backend/communication/jdbc/QueryHeaderMergedResultMetaData.java → sharding-proxy/sharding-proxy-backend/src/main/java/org/apache/shardingsphere/shardingproxy/backend/communication/jdbc/QueryHeaderEncryptorMetaData.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.shardingproxy.backend.communication.jdbc;
 
 import com.google.common.base.Optional;
 import lombok.RequiredArgsConstructor;
-import org.apache.shardingsphere.core.merge.MergedResultMetaData;
+import org.apache.shardingsphere.core.merge.encrypt.dql.EncryptorMetaData;
 import org.apache.shardingsphere.core.rule.EncryptRule;
 import org.apache.shardingsphere.shardingproxy.backend.response.query.QueryHeader;
 import org.apache.shardingsphere.spi.encrypt.ShardingEncryptor;
@@ -27,12 +27,12 @@ import org.apache.shardingsphere.spi.encrypt.ShardingEncryptor;
 import java.util.List;
 
 /**
- * Merged result meta data for query header.
+ * Encryptor meta data for query header.
  *
  * @author zhangliang
  */
 @RequiredArgsConstructor
-public final class QueryHeaderMergedResultMetaData implements MergedResultMetaData {
+public final class QueryHeaderEncryptorMetaData implements EncryptorMetaData {
     
     private final EncryptRule encryptRule;
     

sharding-proxy/sharding-proxy-backend/src/main/java/org/apache/shardingsphere/shardingproxy/backend/text/admin/ShowDatabasesBackendHandler.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.shardingproxy.backend.text.admin;
 
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.dal.show.ShowDatabasesMergedResult;
+import org.apache.shardingsphere.core.merge.dal.common.SingleLocalDataMergedResult;
 import org.apache.shardingsphere.shardingproxy.backend.communication.jdbc.connection.BackendConnection;
 import org.apache.shardingsphere.shardingproxy.backend.response.BackendResponse;
 import org.apache.shardingsphere.shardingproxy.backend.response.query.QueryData;
@@ -49,13 +49,14 @@ public final class ShowDatabasesBackendHandler implements TextProtocolBackendHan
     
     private MergedResult mergedResult;
     
+    @SuppressWarnings("unchecked")
     @Override
     public BackendResponse execute() {
-        mergedResult = new ShowDatabasesMergedResult(getSchemaNames());
+        mergedResult = new SingleLocalDataMergedResult(getSchemaNames());
         return new QueryResponse(Collections.singletonList(new QueryHeader("information_schema", "SCHEMATA", "Database", "SCHEMA_NAME", 100, Types.VARCHAR, 0, false, false, false, false)));
     }
     
-    private Collection<String> getSchemaNames() {
+    private Collection getSchemaNames() {
         Collection<String> result = new LinkedList<>(LogicSchemas.getInstance().getSchemaNames());
         Collection<String> authorizedSchemas = ShardingProxyContext.getInstance().getAuthentication().getUsers().get(backendConnection.getUserName()).getAuthorizedSchemas();
         if (!authorizedSchemas.isEmpty()) {

sharding-proxy/sharding-proxy-backend/src/main/java/org/apache/shardingsphere/shardingproxy/backend/text/sctl/hint/internal/executor/HintShowStatusExecutor.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.shardingproxy.backend.text.sctl.hint.internal.
 
 import org.apache.shardingsphere.api.hint.HintManager;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.dal.show.ShowShardingCTLMergedResult;
+import org.apache.shardingsphere.core.merge.dal.common.MultipleLocalDataMergedResult;
 import org.apache.shardingsphere.shardingproxy.backend.response.query.QueryHeader;
 import org.apache.shardingsphere.shardingproxy.backend.text.sctl.hint.internal.HintShardingType;
 import org.apache.shardingsphere.shardingproxy.backend.text.sctl.hint.internal.command.HintShowStatusCommand;
@@ -48,7 +48,7 @@ public final class HintShowStatusExecutor extends AbstractHintQueryExecutor<Hint
     protected MergedResult createMergedResult() {
         HintShardingType shardingType = HintManager.isDatabaseShardingOnly() ? HintShardingType.DATABASES_ONLY : HintShardingType.DATABASES_TABLES;
         List<Object> row = createRow(HintManager.isMasterRouteOnly(), shardingType);
-        return new ShowShardingCTLMergedResult(Collections.singletonList(row));
+        return new MultipleLocalDataMergedResult(Collections.singletonList(row));
     }
     
     private List<Object> createRow(final boolean masterOnly, final HintShardingType shardingType) {

sharding-proxy/sharding-proxy-backend/src/main/java/org/apache/shardingsphere/shardingproxy/backend/text/sctl/hint/internal/executor/HintShowTableStatusExecutor.java

@@ -21,7 +21,7 @@ import com.google.common.base.Joiner;
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.api.hint.HintManager;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.dal.show.ShowShardingCTLMergedResult;
+import org.apache.shardingsphere.core.merge.dal.common.MultipleLocalDataMergedResult;
 import org.apache.shardingsphere.core.rule.TableRule;
 import org.apache.shardingsphere.shardingproxy.backend.communication.jdbc.connection.BackendConnection;
 import org.apache.shardingsphere.shardingproxy.backend.response.query.QueryHeader;
@@ -92,11 +92,11 @@ public final class HintShowTableStatusExecutor extends AbstractHintQueryExecutor
     }
     
     private MergedResult convert2MergedResult(final Collection<HintShowTableStatusResult> hintShowTableStatusResults) {
-        List<List<Object>> values = new ArrayList<>(hintShowTableStatusResults.size());
+        Collection<List<Object>> values = new ArrayList<>(hintShowTableStatusResults.size());
         for (HintShowTableStatusResult each : hintShowTableStatusResults) {
             values.add(createRow(each));
         }
-        return new ShowShardingCTLMergedResult(values);
+        return new MultipleLocalDataMergedResult(values);
     }
     
     private List<Object> createRow(final HintShowTableStatusResult hintShowTableStatusResult) {

sharding-proxy/sharding-proxy-backend/src/main/java/org/apache/shardingsphere/shardingproxy/backend/text/sctl/show/ShardingCTLShowBackendHandler.java

@@ -19,7 +19,7 @@ package org.apache.shardingsphere.shardingproxy.backend.text.sctl.show;
 
 import com.google.common.base.Optional;
 import org.apache.shardingsphere.core.merge.MergedResult;
-import org.apache.shardingsphere.core.merge.dal.show.ShowShardingCTLMergedResult;
+import org.apache.shardingsphere.core.merge.dal.common.MultipleLocalDataMergedResult;
 import org.apache.shardingsphere.shardingproxy.backend.communication.jdbc.connection.BackendConnection;
 import org.apache.shardingsphere.shardingproxy.backend.response.BackendResponse;
 import org.apache.shardingsphere.shardingproxy.backend.response.error.ErrorResponse;
@@ -70,7 +70,7 @@ public final class ShardingCTLShowBackendHandler implements TextProtocolBackendH
     }
     
     private BackendResponse createResponsePackets(final String columnName, final Object... values) {
-        mergedResult = new ShowShardingCTLMergedResult(Collections.singletonList(Arrays.asList(values)));
+        mergedResult = new MultipleLocalDataMergedResult(Collections.singletonList(Arrays.asList(values)));
         return new QueryResponse(Collections.singletonList(new QueryHeader("", "", columnName, columnName, 100, Types.VARCHAR, 0, false, false, false, false)));
     }