diff --git a/sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/rewriter/EncryptSQLRewriteEngineTest.java b/sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/rewriter/EncryptSQLRewriteEngineTest.java
index 3cb0864ab22f9..c6ae4d3b89883 100644
--- a/sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/rewriter/EncryptSQLRewriteEngineTest.java
+++ b/sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/rewriter/EncryptSQLRewriteEngineTest.java
@@ -48,14 +48,17 @@ public final class EncryptSQLRewriteEngineTest {
     
     private EncryptRule encryptRule;
     
-    private List<Object> parameters;
+    private List<Object> parametersOfEqual;
+    
+    private List<Object> parametersOfIn;
     
     private SQLParseEngine parseEngine;
     
     @Before
     public void setUp() {
         encryptRule = new EncryptRule(createEncryptRuleConfiguration());
-        parameters = Arrays.<Object>asList(1, 2);
+        parametersOfEqual = Arrays.<Object>asList(1, 2);
+        parametersOfIn = Arrays.<Object>asList(1, 2, 3, 4);
         parseEngine = new SQLParseEngine(DatabaseTypes.getActualDatabaseType("MySQL"));
     }
     
@@ -67,6 +70,8 @@ private EncryptRuleConfiguration createEncryptRuleConfiguration() {
         result.getEncryptors().put("assistedTest", encryptorQueryConfig);
         result.getTables().put("t_encrypt", createEncryptTableConfig1());
         result.getTables().put("t_query_encrypt", createEncryptTableConfig2());
+        result.getTables().put("t_plain_encrypt", createEncryptTableConfig3());
+        result.getTables().put("t_plain_query", createEncryptTableConfig4());
         return result;
     }
     
@@ -87,29 +92,67 @@ private EncryptTableRuleConfiguration createEncryptTableConfig2() {
         columns2.put("col2", columnConfig2);
         return new EncryptTableRuleConfiguration(columns2);
     }
+    
+    private EncryptTableRuleConfiguration createEncryptTableConfig3() {
+        EncryptColumnRuleConfiguration columnConfig1 = new EncryptColumnRuleConfiguration("plain1", "col1", "", "test");
+        EncryptColumnRuleConfiguration columnConfig2 = new EncryptColumnRuleConfiguration("plain2", "col2", "", "test");
+        Map<String, EncryptColumnRuleConfiguration> columns2 = new LinkedHashMap<>();
+        columns2.put("col3", columnConfig1);
+        columns2.put("col4", columnConfig2);
+        return new EncryptTableRuleConfiguration(columns2);
+    }
+    
+    private EncryptTableRuleConfiguration createEncryptTableConfig4() {
+        EncryptColumnRuleConfiguration columnConfig1 = new EncryptColumnRuleConfiguration("plain1", "col1", "query1", "assistedTest");
+        EncryptColumnRuleConfiguration columnConfig2 = new EncryptColumnRuleConfiguration("plain2", "col2", "query2", "assistedTest");
+        Map<String, EncryptColumnRuleConfiguration> columns2 = new LinkedHashMap<>();
+        columns2.put("col3", columnConfig1);
+        columns2.put("col4", columnConfig2);
+        return new EncryptTableRuleConfiguration(columns2);
+    }
 
     @Test
     public void assertSelectWithoutPlaceholderWithEncrypt() {
         String sql = "SELECT * FROM t_encrypt WHERE col1 = 1 or col2 = 2";
-        SQLUnit actual = getSQLUnit(sql, Collections.emptyList());
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), true);
         assertThat(actual.getSql(), is("SELECT * FROM t_encrypt WHERE col1 = 'encryptValue' or col2 = 'encryptValue'"));
         assertThat(actual.getParameters().size(), is(0));
     }
     
+    @Test
+    public void assertSelectWithoutPlaceholderWithPlainEncrypt() {
+        String sql = "SELECT * FROM t_plain_encrypt WHERE col3 = 1 or col4 = 2";
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), true);
+        assertThat(actual.getSql(), is("SELECT * FROM t_plain_encrypt WHERE col1 = 'encryptValue' or col2 = 'encryptValue'"));
+        assertThat(actual.getParameters().size(), is(0));
+    }
+    
     @Test
     public void assertSelectWithPlaceholderWithQueryEncrypt() {
-        String sql = "SELECT * FROM t_query_encrypt WHERE col1 = ? or col2 = ?";
-        SQLUnit actual = getSQLUnit(sql, parameters);
-        assertThat(actual.getSql(), is("SELECT * FROM t_query_encrypt WHERE query1 = ? or query2 = ?"));
-        assertThat(actual.getParameters().size(), is(2));
+        String sql = "SELECT * FROM t_plain_query WHERE col3 in (?, ?) and col4 in (?, ?)";
+        SQLUnit actual = getSQLUnit(sql, parametersOfIn, true);
+        assertThat(actual.getSql(), is("SELECT * FROM t_plain_query WHERE query1 IN (?, ?) and query2 IN (?, ?)"));
+        assertThat(actual.getParameters().size(), is(4));
         assertThat(actual.getParameters().get(0), is((Object) "assistedEncryptValue"));
         assertThat(actual.getParameters().get(1), is((Object) "assistedEncryptValue"));
+        assertThat(actual.getParameters().get(2), is((Object) "assistedEncryptValue"));
+        assertThat(actual.getParameters().get(2), is((Object) "assistedEncryptValue"));
+    }
+    
+    @Test
+    public void assertSelectWithPlaceholderWithQueryPlainEncrypt() {
+        String sql = "SELECT * FROM t_plain_query WHERE col3 = ? or col4 = ?";
+        SQLUnit actual = getSQLUnit(sql, parametersOfEqual, false);
+        assertThat(actual.getSql(), is("SELECT * FROM t_plain_query WHERE plain1 = ? or plain2 = ?"));
+        assertThat(actual.getParameters().size(), is(2));
+        assertThat(actual.getParameters().get(0), is((Object) 1));
+        assertThat(actual.getParameters().get(1), is((Object) 2));
     }
     
     @Test
     public void assertDeleteWithPlaceholderWithEncrypt() {
         String sql = "DELETE FROM t_encrypt WHERE col1 = ? and col2 = ?";
-        SQLUnit actual = getSQLUnit(sql, parameters);
+        SQLUnit actual = getSQLUnit(sql, parametersOfEqual, true);
         assertThat(actual.getSql(), is("DELETE FROM t_encrypt WHERE col1 = ? and col2 = ?"));
         assertThat(actual.getParameters().size(), is(2));
         assertThat(actual.getParameters().get(0), is((Object) "encryptValue"));
@@ -117,26 +160,55 @@ public void assertDeleteWithPlaceholderWithEncrypt() {
         
     }
     
+    @Test
+    public void assertDeleteWithPlaceholderWithPlainEncrypt() {
+        String sql = "DELETE FROM t_plain_encrypt WHERE col3 in (?, ?) or col4 in (?, ?)";
+        SQLUnit actual = getSQLUnit(sql, parametersOfIn, false);
+        assertThat(actual.getSql(), is("DELETE FROM t_plain_encrypt WHERE plain1 IN (?, ?) or plain2 IN (?, ?)"));
+        assertThat(actual.getParameters().size(), is(4));
+        assertThat(actual.getParameters().get(0), is((Object) 1));
+        assertThat(actual.getParameters().get(1), is((Object) 2));
+        assertThat(actual.getParameters().get(2), is((Object) 3));
+        assertThat(actual.getParameters().get(3), is((Object) 4));
+        
+    }
+    
     @Test
     public void assertDeleteWithoutPlaceholderWithQueryEncrypt() {
         String sql = "DELETE FROM t_query_encrypt WHERE col1 = 1 and col2 = 2";
-        SQLUnit actual = getSQLUnit(sql, Collections.emptyList());
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), true);
         assertThat(actual.getSql(), is("DELETE FROM t_query_encrypt WHERE query1 = 'assistedEncryptValue' and query2 = 'assistedEncryptValue'"));
         assertThat(actual.getParameters().size(), is(0));
     }
     
+    @Test
+    public void assertDeleteWithoutPlaceholderWithQueryPlainEncrypt() {
+        String sql = "DELETE FROM t_plain_query WHERE col3 = 1 or col4 IN (2,3,4)";
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), true);
+        assertThat(actual.getSql(), is("DELETE FROM t_plain_query WHERE query1 = 'assistedEncryptValue' or query2 IN ('assistedEncryptValue', 'assistedEncryptValue', 'assistedEncryptValue')"));
+        assertThat(actual.getParameters().size(), is(0));
+    }
+    
     @Test
     public void assertUpdateWithoutPlaceholderWithEncrypt() {
         String sql = "UPDATE t_encrypt set col1 = 3 where col2 = 2";
-        SQLUnit actual = getSQLUnit(sql, Collections.emptyList());
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), true);
         assertThat(actual.getSql(), is("UPDATE t_encrypt set col1 = 'encryptValue' where col2 = 'encryptValue'"));
         assertThat(actual.getParameters().size(), is(0));
     }
     
+    @Test
+    public void assertUpdateWithoutPlaceholderWithPlainEncrypt() {
+        String sql = "UPDATE t_plain_encrypt set col3 = 3 where col4 = 2";
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), false);
+        assertThat(actual.getSql(), is("UPDATE t_plain_encrypt set plain1 = 3, col1 = 'encryptValue' where plain2 = '2'"));
+        assertThat(actual.getParameters().size(), is(0));
+    }
+    
     @Test
     public void assertUpdateWithPlaceholderWithQueryEncrypt() {
         String sql = "UPDATE t_query_encrypt set col1 = ? where col2 = ?";
-        SQLUnit actual = getSQLUnit(sql, parameters);
+        SQLUnit actual = getSQLUnit(sql, parametersOfEqual, true);
         assertThat(actual.getSql(), is("UPDATE t_query_encrypt set col1 = ?, query1 = ? where query2 = ?"));
         assertThat(actual.getParameters().size(), is(3));
         assertThat(actual.getParameters().get(0), is((Object) "encryptValue"));
@@ -144,10 +216,22 @@ public void assertUpdateWithPlaceholderWithQueryEncrypt() {
         assertThat(actual.getParameters().get(2), is((Object) "assistedEncryptValue"));
     }
     
+    @Test
+    public void assertUpdateWithPlaceholderWithQueryPlainEncrypt() {
+        String sql = "UPDATE t_plain_query set col3 = ? where col4 = ?";
+        SQLUnit actual = getSQLUnit(sql, parametersOfEqual, true);
+        assertThat(actual.getSql(), is("UPDATE t_plain_query set plain1 = ?, col1 = ?, query1 = ? where query2 = ?"));
+        assertThat(actual.getParameters().size(), is(4));
+        assertThat(actual.getParameters().get(0), is((Object) 1));
+        assertThat(actual.getParameters().get(1), is((Object) "encryptValue"));
+        assertThat(actual.getParameters().get(2), is((Object) "assistedEncryptValue"));
+        assertThat(actual.getParameters().get(3), is((Object) "assistedEncryptValue"));
+    }
+    
     @Test
     public void assertInsertWithValuesWithPlaceholderWithEncrypt() {
         String sql = "INSERT INTO t_encrypt(col1, col2) VALUES (?, ?), (3, 4)";
-        SQLUnit actual = getSQLUnit(sql, parameters);
+        SQLUnit actual = getSQLUnit(sql, parametersOfEqual, true);
         assertThat(actual.getSql(), is("INSERT INTO t_encrypt(col1, col2) VALUES (?, ?), ('encryptValue', 'encryptValue')"));
         assertThat(actual.getParameters().size(), is(2));
         assertThat(actual.getParameters().get(0), is((Object) "encryptValue"));
@@ -157,24 +241,42 @@ public void assertInsertWithValuesWithPlaceholderWithEncrypt() {
     @Test
     public void assertInsertWithValuesWithoutPlaceholderWithQueryEncrypt() {
         String sql = "INSERT INTO t_query_encrypt(col1, col2) VALUES (1, 2), (3, 4)";
-        SQLUnit actual = getSQLUnit(sql, Collections.emptyList());
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), true);
         assertThat(actual.getSql(), is("INSERT INTO t_query_encrypt(col1, col2, query1, query2) " 
                 + "VALUES ('encryptValue', 'encryptValue', 'assistedEncryptValue', 'assistedEncryptValue'), ('encryptValue', 'encryptValue', 'assistedEncryptValue', 'assistedEncryptValue')"));
         assertThat(actual.getParameters().size(), is(0));
     }
     
+    @Test
+    public void assertInsertWithValuesWithoutPlaceholderWithQueryPlainEncrypt() {
+        String sql = "INSERT INTO t_plain_query(col3, col4) VALUES (1, 2), (3, 4)";
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), true);
+        assertThat(actual.getSql(), is("INSERT INTO t_plain_query(col1, col2, query1, query2, plain1, plain2) " 
+                + "VALUES ('encryptValue', 'encryptValue', 'assistedEncryptValue', 'assistedEncryptValue', 1, 2), " 
+                + "('encryptValue', 'encryptValue', 'assistedEncryptValue', 'assistedEncryptValue', 3, 4)"));
+        assertThat(actual.getParameters().size(), is(0));
+    }
+    
     @Test
     public void assertInsertWithSetWithoutPlaceholderWithEncrypt() {
         String sql = "INSERT INTO t_encrypt SET col1 = 1, col2 = 2";
-        SQLUnit actual = getSQLUnit(sql, Collections.emptyList());
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), true);
         assertThat(actual.getSql(), is("INSERT INTO t_encrypt SET col1 = 'encryptValue', col2 = 'encryptValue'"));
         assertThat(actual.getParameters().size(), is(0));
     }
     
+    @Test
+    public void assertInsertWithSetWithoutPlaceholderWithPlainEncrypt() {
+        String sql = "INSERT INTO t_plain_encrypt SET col3 = 1, col4 = 2";
+        SQLUnit actual = getSQLUnit(sql, Collections.emptyList(), true);
+        assertThat(actual.getSql(), is("INSERT INTO t_plain_encrypt SET col1 = 'encryptValue', col2 = 'encryptValue', plain1 = 1, plain2 = 2"));
+        assertThat(actual.getParameters().size(), is(0));
+    }
+    
     @Test
     public void assertInsertWithSetWithPlaceholderWithQueryEncrypt() {
         String sql = "INSERT INTO t_query_encrypt SET col1 = ?, col2 = ?";
-        SQLUnit actual = getSQLUnit(sql, parameters);
+        SQLUnit actual = getSQLUnit(sql, parametersOfEqual, true);
         assertThat(actual.getSql(), is("INSERT INTO t_query_encrypt SET col1 = ?, col2 = ?, query1 = ?, query2 = ?"));
         assertThat(actual.getParameters().size(), is(4));
         assertThat(actual.getParameters().get(0), is((Object) "encryptValue"));
@@ -183,12 +285,26 @@ public void assertInsertWithSetWithPlaceholderWithQueryEncrypt() {
         assertThat(actual.getParameters().get(3), is((Object) "assistedEncryptValue"));
     }
     
+    @Test
+    public void assertInsertWithSetWithPlaceholderWithQueryPlainEncrypt() {
+        String sql = "INSERT INTO t_plain_query SET col3 = ?, col4 = ?";
+        SQLUnit actual = getSQLUnit(sql, parametersOfEqual, false);
+        assertThat(actual.getSql(), is("INSERT INTO t_plain_query SET col1 = ?, col2 = ?, query1 = ?, query2 = ?, plain1 = ?, plain2 = ?"));
+        assertThat(actual.getParameters().size(), is(6));
+        assertThat(actual.getParameters().get(0), is((Object) "encryptValue"));
+        assertThat(actual.getParameters().get(1), is((Object) "encryptValue"));
+        assertThat(actual.getParameters().get(2), is((Object) "assistedEncryptValue"));
+        assertThat(actual.getParameters().get(3), is((Object) "assistedEncryptValue"));
+        assertThat(actual.getParameters().get(4), is((Object) 1));
+        assertThat(actual.getParameters().get(5), is((Object) 2));
+    }
+    
     @SuppressWarnings("unchecked")
-    private SQLUnit getSQLUnit(final String sql, final List<Object> parameters) {
+    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 optimizedStatement = EncryptOptimizeEngineFactory.newInstance(sqlStatement).optimize(encryptRule, mock(ShardingTableMetaData.class), sql, parameters, sqlStatement);
-        SQLRewriteEngine sqlRewriteEngine = new SQLRewriteEngine(encryptRule, optimizedStatement, sql, parameters, true);
+        SQLRewriteEngine sqlRewriteEngine = new SQLRewriteEngine(encryptRule, optimizedStatement, sql, parameters, isQueryWithCipherColumn);
         return sqlRewriteEngine.generateSQL();
     }
 }
diff --git a/sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/rewriter/ShardingSQLRewriteEngineTest.java b/sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/rewriter/ShardingSQLRewriteEngineTest.java
index bddf3bcb889b4..98bdf40cc37de 100644
--- a/sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/rewriter/ShardingSQLRewriteEngineTest.java
+++ b/sharding-core/sharding-core-rewrite/src/test/java/org/apache/shardingsphere/core/rewrite/rewriter/ShardingSQLRewriteEngineTest.java
@@ -886,9 +886,15 @@ private SQLRouteResult createSQLRouteResultForTableTokenWithSchemaForDelete() {
     }
     
     @Test
-    public void assertRewriteSelectInWithShardingEncryptor() {
+    public void assertRewriteSelectInWithShardingEncryptorWithCipher() {
         SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(createSQLRouteResultForSelectInWithShardingEncryptor(), "SELECT id FROM table_z WHERE id in (3,5)", Collections.emptyList());
-        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("SELECT id FROM table_z WHERE id IN ('encryptValue', 'encryptValue')"));
+        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("SELECT id FROM table_z WHERE cipher IN ('encryptValue', 'encryptValue')"));
+    }
+    
+    @Test
+    public void assertRewriteSelectInWithShardingEncryptorWithPlain() {
+        SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(createSQLRouteResultForSelectInWithShardingEncryptor(), "SELECT id FROM table_z WHERE id in (3,5)", Collections.emptyList(), false);
+        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("SELECT id FROM table_z WHERE plain IN ('3', '5')"));
     }
     
     private SQLRouteResult createSQLRouteResultForSelectInWithShardingEncryptor() {
@@ -907,11 +913,11 @@ private SQLRouteResult createSQLRouteResultForSelectInWithShardingEncryptor() {
     }
     
     @Test
-    public void assertRewriteSelectInWithQueryAssistedShardingEncryptor() {
+    public void assertRewriteSelectInWithQueryAssistedShardingEncryptorWithQuery() {
         SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(
                 createSQLRouteResultForSelectInWithQueryAssistedShardingEncryptor(), "SELECT id FROM table_k WHERE id in (3,5)", Collections.emptyList());
         assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(),
-                is("SELECT id FROM table_k WHERE query_id IN ('assistedEncryptValue', 'assistedEncryptValue')"));
+                is("SELECT id FROM table_k WHERE query IN ('assistedEncryptValue', 'assistedEncryptValue')"));
     }
     
     private SQLRouteResult createSQLRouteResultForSelectInWithQueryAssistedShardingEncryptor() {
@@ -932,14 +938,14 @@ private SQLRouteResult createSQLRouteResultForSelectInWithQueryAssistedShardingE
     @Test
     public void assertRewriteUpdateWithShardingEncryptor() {
         SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(createSQLRouteResultForUpdateWithShardingEncryptor(), "UPDATE table_z SET id = 1 WHERE id = 2", Collections.emptyList());
-        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("UPDATE table_z SET id = 'encryptValue' WHERE id = 'encryptValue'"));
+        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("UPDATE table_z SET plain = 1, cipher = 'encryptValue' WHERE cipher = 'encryptValue'"));
     }
     
     private SQLRouteResult createSQLRouteResultForUpdateWithShardingEncryptor() {
         UpdateStatement updateStatement = new UpdateStatement();
         updateStatement.getAllSQLSegments().add(new TableSegment(7, 13, "table_z"));
         updateStatement.setSetAssignment(
-                new SetAssignmentsSegment(15, 24, Collections.singleton(new AssignmentSegment(19, 24, new ColumnSegment(19, 20, "id"), new LiteralExpressionSegment(0, 0, 2)))));
+                new SetAssignmentsSegment(15, 24, Collections.singleton(new AssignmentSegment(19, 24, new ColumnSegment(19, 20, "id"), new LiteralExpressionSegment(0, 0, 1)))));
         List<EncryptCondition> encryptConditions = new LinkedList<>();
         encryptConditions.add(new EncryptCondition("id", "table_z", 32, 37, new LiteralExpressionSegment(0, 0, 2)));
         SQLRouteResult result = new SQLRouteResult(
@@ -953,7 +959,7 @@ public void assertRewriteInsertWithQueryAssistedShardingEncryptor() {
         SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(
                 createSQLRouteResultForInsertWithQueryAssistedShardingEncryptor(), "INSERT INTO `table_w` set name = 10 ON DUPLICATE KEY UPDATE name = VALUES(name)", Collections.emptyList());
         assertThat(rewriteEngine.generateSQL(routingUnit, logicTableAndActualTables).getSql(),
-                is("INSERT INTO `table_w` set name = 'encryptValue', id = 1, query_name = 'assistedEncryptValue' ON DUPLICATE KEY UPDATE name = VALUES(name)"));
+                is("INSERT INTO `table_w` set cipher = 'encryptValue', id = 1, query = 'assistedEncryptValue', plain = 1 ON DUPLICATE KEY UPDATE name = VALUES(name)"));
     }
     
     private SQLRouteResult createSQLRouteResultForInsertWithQueryAssistedShardingEncryptor() {
@@ -966,10 +972,11 @@ private SQLRouteResult createSQLRouteResultForInsertWithQueryAssistedShardingEnc
         insertStatement.setTable(new TableSegment(0, 0, "table_w"));
         ShardingInsertColumns insertColumns = mock(ShardingInsertColumns.class);
         when(insertColumns.getRegularColumnNames()).thenReturn(Collections.singletonList("name"));
-        when(insertColumns.getAllColumnNames()).thenReturn(Arrays.asList("name", "id", "query_name"));
+        when(insertColumns.getAllColumnNames()).thenReturn(Arrays.asList("name", "plain", "id", "query"));
         ShardingInsertOptimizedStatement optimizedStatement = new ShardingInsertOptimizedStatement(insertStatement, Collections.<ShardingCondition>emptyList(), insertColumns, 
                 Collections.singletonList(new InsertValue(Collections.<ExpressionSegment>singletonList(new LiteralExpressionSegment(33, 34, 10)))), null);
-        ExpressionSegment[] expressionSegments = {new LiteralExpressionSegment(0, 0, 10), new LiteralExpressionSegment(0, 0, 1), new LiteralExpressionSegment(0, 0, 10)};
+        ExpressionSegment[] expressionSegments = 
+                {new LiteralExpressionSegment(0, 0, 10), new LiteralExpressionSegment(0, 0, 1), new LiteralExpressionSegment(0, 0, 1), new LiteralExpressionSegment(0, 0, 10)};
         InsertOptimizeResultUnit unit = optimizedStatement.createUnit(expressionSegments, new Object[0], 0);
         optimizedStatement.addUnit(unit);
         optimizedStatement.getUnits().get(0).getDataNodes().add(new DataNode("db0.table_1"));
@@ -1004,13 +1011,21 @@ private SQLRouteResult createSQLRouteResultForSelectInWithAggregationDistinct()
     }
     
     @Test
-    public void assertRewriteSelectEqualWithShardingEncryptor() {
+    public void assertRewriteSelectEqualWithShardingEncryptorWithCipher() {
         SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(
                 createSQLRouteResultForSelectEqualWithShardingEncryptor(), "SELECT id FROM table_z WHERE id=? AND name=?", Arrays.<Object>asList(1, "x"));
-        assertThat(rewriteEngine.generateSQL().getSql(), is("SELECT id FROM table_z WHERE id = ? AND name=?"));
+        assertThat(rewriteEngine.generateSQL().getSql(), is("SELECT id FROM table_z WHERE cipher = ? AND name=?"));
         assertThat(getParameterBuilder(rewriteEngine).getParameters().get(0), is((Object) "encryptValue"));
     }
     
+    @Test
+    public void assertRewriteSelectEqualWithShardingEncryptorWithPlain() {
+        SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(
+                createSQLRouteResultForSelectEqualWithShardingEncryptor(), "SELECT id FROM table_z WHERE id=? AND name=?", Arrays.<Object>asList(1, "x"), false);
+        assertThat(rewriteEngine.generateSQL().getSql(), is("SELECT id FROM table_z WHERE plain = ? AND name=?"));
+        assertThat(getParameterBuilder(rewriteEngine).getParameters().get(0), is((Object) 1));
+    }
+    
     private SQLRouteResult createSQLRouteResultForSelectEqualWithShardingEncryptor() {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(new TableSegment(15, 21, "table_z"));
@@ -1024,14 +1039,23 @@ private SQLRouteResult createSQLRouteResultForSelectEqualWithShardingEncryptor()
     }
     
     @Test
-    public void assertRewriteSelectInWithShardingEncryptorWithParameter() {
+    public void assertRewriteSelectInWithShardingEncryptorWithParameterWithCipher() {
         SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(
                 createSQLRouteResultForSelectInWithShardingEncryptorWithParameter(), "SELECT id FROM table_z WHERE id in (?, ?) or id = 3", Arrays.<Object>asList(1, 2));
-        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("SELECT id FROM table_z WHERE id IN (?, ?) or id = 'encryptValue'"));
+        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("SELECT id FROM table_z WHERE cipher IN (?, ?) or cipher = 'encryptValue'"));
         assertThat(getParameterBuilder(rewriteEngine).getParameters().get(0), is((Object) "encryptValue"));
         assertThat(getParameterBuilder(rewriteEngine).getParameters().get(1), is((Object) "encryptValue"));
     }
     
+    @Test
+    public void assertRewriteSelectInWithShardingEncryptorWithParameterWithPlain() {
+        SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(
+                createSQLRouteResultForSelectInWithShardingEncryptorWithParameter(), "SELECT id FROM table_z WHERE id in (?, ?) or id = 3", Arrays.<Object>asList(1, 2), false);
+        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("SELECT id FROM table_z WHERE plain IN (?, ?) or plain = '3'"));
+        assertThat(getParameterBuilder(rewriteEngine).getParameters().get(0), is((Object) 1));
+        assertThat(getParameterBuilder(rewriteEngine).getParameters().get(1), is((Object) 2));
+    }
+    
     private SQLRouteResult createSQLRouteResultForSelectInWithShardingEncryptorWithParameter() {
         SelectStatement selectStatement = new SelectStatement();
         selectStatement.getAllSQLSegments().add(new TableSegment(15, 21, "table_z"));
@@ -1052,7 +1076,7 @@ private SQLRouteResult createSQLRouteResultForSelectInWithShardingEncryptorWithP
     public void assertRewriteSelectEqualWithQueryAssistedShardingEncryptor() {
         SQLRewriteEngine rewriteEngine = createSQLRewriteEngine(
                 createSQLRouteResultForSelectEqualWithQueryAssistedShardingEncryptor(), "SELECT id FROM table_k WHERE id=? AND name=?", Arrays.<Object>asList(1, "k"));
-        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("SELECT id FROM table_k WHERE query_id = ? AND name=?"));
+        assertThat(rewriteEngine.generateSQL(null, logicTableAndActualTables).getSql(), is("SELECT id FROM table_k WHERE query = ? AND name=?"));
         assertThat(getParameterBuilder(rewriteEngine).getParameters().get(0), is((Object) "assistedEncryptValue"));
     }
     
@@ -1069,7 +1093,11 @@ private SQLRouteResult createSQLRouteResultForSelectEqualWithQueryAssistedShardi
     }
     
     private SQLRewriteEngine createSQLRewriteEngine(final SQLRouteResult routeResult, final String sql, final List<Object> parameters) {
-        return new SQLRewriteEngine(shardingRule, routeResult, sql, parameters, routeResult.getRoutingResult().isSingleRouting(), true);
+        return createSQLRewriteEngine(routeResult, sql, parameters, true);
+    }
+    
+    private SQLRewriteEngine createSQLRewriteEngine(final SQLRouteResult routeResult, final String sql, final List<Object> parameters, final boolean isQueryWithCipherColumn) {
+        return new SQLRewriteEngine(shardingRule, routeResult, sql, parameters, routeResult.getRoutingResult().isSingleRouting(), isQueryWithCipherColumn);
     }
     
     @SneakyThrows
diff --git a/sharding-core/sharding-core-rewrite/src/test/resources/yaml/rewrite-rule.yaml b/sharding-core/sharding-core-rewrite/src/test/resources/yaml/rewrite-rule.yaml
index f5377cea08449..36b5f8569ff81 100644
--- a/sharding-core/sharding-core-rewrite/src/test/resources/yaml/rewrite-rule.yaml
+++ b/sharding-core/sharding-core-rewrite/src/test/resources/yaml/rewrite-rule.yaml
@@ -48,7 +48,7 @@ shardingRule:
         type: SNOWFLAKE
         column: id
         props:
-          worker.id: 123
+          worker.id: 123 
   bindingTables:
     - table_x, table_y
   encryptRule:
@@ -61,13 +61,14 @@ shardingRule:
       table_z:
         columns:
           id:
-            cipherColumn: id
+            cipherColumn: cipher
+            plainColumn: plain
             encryptor: z_encryptor
       table_k:
         columns:
           id:
-            cipherColumn: id
-            assistedQueryColumn: query_id
+            cipherColumn: cipher
+            assistedQueryColumn: query
             encryptor: k_encryptor
           id1:
             cipherColumn: id1
@@ -76,6 +77,7 @@ shardingRule:
       table_w:
         columns:
           name:
-            cipherColumn: name
-            assistedQueryColumn: query_name
+            plainColumn: plain
+            cipherColumn: cipher
+            assistedQueryColumn: query
             encryptor: k_encryptor