You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by du...@apache.org on 2022/11/03 14:43:12 UTC
[shardingsphere] branch master updated: rewrite the sql while LIKE operator contained and UT, SIT (#21940)
This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new baa5c75c663 rewrite the sql while LIKE operator contained and UT, SIT (#21940)
baa5c75c663 is described below
commit baa5c75c66386df93ea9eb36b043f9cbf2084f0c
Author: gxxiong <xi...@foxmail.com>
AuthorDate: Thu Nov 3 22:42:56 2022 +0800
rewrite the sql while LIKE operator contained and UT, SIT (#21940)
---
.../AbstractEncryptRuleConfigurationChecker.java | 13 ++++
.../rewrite/condition/EncryptConditionEngine.java | 22 ++++--
.../condition/impl/EncryptLikeCondition.java | 89 ++++++++++++++++++++++
.../EncryptAssignmentParameterRewriter.java | 4 +
...OnDuplicateKeyUpdateValueParameterRewriter.java | 6 ++
.../EncryptInsertValueParameterRewriter.java | 21 +++--
.../EncryptPredicateParameterRewriter.java | 5 ++
...stQueryAndPlainInsertColumnsTokenGenerator.java | 1 +
.../generator/EncryptAssignmentTokenGenerator.java | 16 ++++
.../EncryptCreateTableTokenGenerator.java | 7 ++
.../EncryptInsertOnUpdateTokenGenerator.java | 23 ++++++
.../EncryptInsertValuesTokenGenerator.java | 16 ++++
.../EncryptPredicateColumnTokenGenerator.java | 63 ++++++++++++++-
.../EncryptPredicateRightValueTokenGenerator.java | 10 +++
.../impl/EncryptCreateTableTokenGeneratorTest.java | 6 +-
.../EncryptInsertValuesTokenGeneratorTest.java | 20 ++---
test/parser/src/main/resources/case/rdl/alter.xml | 16 ++++
test/parser/src/main/resources/case/rdl/create.xml | 16 ++++
.../src/main/resources/sql/supported/rdl/alter.xml | 1 +
.../main/resources/sql/supported/rdl/create.xml | 1 +
.../RewriteQueryFuzzyEncryptAlgorithmFixture.java | 53 +++++++++++++
...che.shardingsphere.encrypt.spi.EncryptAlgorithm | 1 +
.../query-with-cipher/ddl/create/create-table.xml | 4 +-
.../case/query-with-cipher/dml/delete/delete.xml | 16 ++--
.../query-with-cipher/dml/insert/insert-column.xml | 44 +++++------
.../dml/insert/insert-on-duplicate.xml | 14 ++--
.../query-with-cipher/dml/insert/insert-set.xml | 16 ++--
.../dml/select/select-group-by.xml | 8 +-
.../dml/select/select-order-by.xml | 4 +-
.../dml/select/select-projection.xml | 4 +-
.../dml/select/select-subquery.xml | 4 +-
.../query-with-cipher/dml/select/select-where.xml | 20 ++---
.../case/query-with-cipher/dml/update/update.xml | 20 ++---
.../query-with-plain/ddl/create/create-table.xml | 4 +-
.../case/query-with-plain/dml/delete/delete.xml | 12 +--
.../query-with-plain/dml/insert/insert-column.xml | 42 +++++-----
.../dml/insert/insert-on-duplicate.xml | 14 ++--
.../query-with-plain/dml/insert/insert-set.xml | 16 ++--
.../dml/select/select-projection.xml | 4 +-
.../query-with-plain/dml/select/select-where.xml | 24 +++---
.../case/query-with-plain/dml/update/update.xml | 16 ++--
.../scenario/encrypt/config/query-with-cipher.yaml | 16 ++++
.../scenario/encrypt/config/query-with-plain.yaml | 16 ++++
43 files changed, 555 insertions(+), 173 deletions(-)
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/AbstractEncryptRuleConfigurationChecker.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/AbstractEncryptRuleConfigurationChecker.java
index d861dbbea02..fb8193c8e59 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/AbstractEncryptRuleConfigurationChecker.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/AbstractEncryptRuleConfigurationChecker.java
@@ -46,6 +46,7 @@ public abstract class AbstractEncryptRuleConfigurationChecker<T extends RuleConf
for (EncryptColumnRuleConfiguration column : each.getColumns()) {
checkCipherColumnConfiguration(databaseName, encryptors, column);
checkAssistColumnConfiguration(databaseName, encryptors, column);
+ checkFuzzyColumnConfiguration(databaseName, encryptors, column);
}
}
}
@@ -71,6 +72,18 @@ public abstract class AbstractEncryptRuleConfigurationChecker<T extends RuleConf
"Can not find assisted query encryptor `%s` in database `%s`.", column.getAssistedQueryEncryptorName(), databaseName);
}
+ private void checkFuzzyColumnConfiguration(final String databaseName, final Collection<String> encryptors, final EncryptColumnRuleConfiguration column) {
+ if (Strings.isNullOrEmpty(column.getFuzzyQueryColumn()) && Strings.isNullOrEmpty(column.getFuzzyQueryEncryptorName())) {
+ return;
+ }
+ Preconditions.checkState(!Strings.isNullOrEmpty(column.getFuzzyQueryColumn()),
+ "Fuzzy query column of `%s` can not be null in database `%s`.", column.getLogicColumn(), databaseName);
+ Preconditions.checkState(!Strings.isNullOrEmpty(column.getFuzzyQueryEncryptorName()),
+ "Fuzzy query encryptor name of `%s` can not be null in database `%s`.", column.getLogicColumn(), databaseName);
+ Preconditions.checkState(encryptors.contains(column.getFuzzyQueryEncryptorName()),
+ "Can not find fuzzy query encryptor `%s` in database `%s`.", column.getFuzzyQueryEncryptorName(), databaseName);
+ }
+
protected abstract Collection<String> getEncryptors(T config);
protected abstract Collection<EncryptTableRuleConfiguration> getTables(T config);
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/condition/EncryptConditionEngine.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/condition/EncryptConditionEngine.java
index ef0db24cead..ee7e4134749 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/condition/EncryptConditionEngine.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/condition/EncryptConditionEngine.java
@@ -21,6 +21,7 @@ import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.encrypt.exception.syntax.UnsupportedEncryptSQLException;
import org.apache.shardingsphere.encrypt.rewrite.condition.impl.EncryptEqualCondition;
import org.apache.shardingsphere.encrypt.rewrite.condition.impl.EncryptInCondition;
+import org.apache.shardingsphere.encrypt.rewrite.condition.impl.EncryptLikeCondition;
import org.apache.shardingsphere.encrypt.rule.EncryptColumn;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
import org.apache.shardingsphere.infra.binder.statement.SQLStatementContext;
@@ -31,6 +32,7 @@ import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.BetweenE
import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.BinaryOperationExpression;
import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.ExpressionSegment;
import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.InExpression;
+import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.ListExpression;
import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.simple.LiteralExpressionSegment;
import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.simple.SimpleExpressionSegment;
import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.subquery.SubqueryExpressionSegment;
@@ -56,7 +58,7 @@ public final class EncryptConditionEngine {
private static final Set<String> LOGICAL_OPERATOR = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
- private static final Set<String> SUPPORTED_COMPARE_OPERATOR = new HashSet<>();
+ private static final Set<String> SUPPORTED_COMPARE_OPERATOR = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
private final EncryptRule encryptRule;
@@ -75,6 +77,7 @@ public final class EncryptConditionEngine {
SUPPORTED_COMPARE_OPERATOR.add(">=");
SUPPORTED_COMPARE_OPERATOR.add("<=");
SUPPORTED_COMPARE_OPERATOR.add("IS");
+ SUPPORTED_COMPARE_OPERATOR.add("LIKE");
}
/**
@@ -165,12 +168,21 @@ public final class EncryptConditionEngine {
}
private Optional<EncryptCondition> createCompareEncryptCondition(final String tableName, final BinaryOperationExpression expression, final ExpressionSegment compareRightValue) {
- if (!(expression.getLeft() instanceof ColumnSegment)) {
+ if (!(expression.getLeft() instanceof ColumnSegment) || (compareRightValue instanceof SubqueryExpressionSegment)) {
return Optional.empty();
}
- return (compareRightValue instanceof SimpleExpressionSegment && !(compareRightValue instanceof SubqueryExpressionSegment))
- ? Optional.of(createEncryptEqualCondition(tableName, expression, compareRightValue))
- : Optional.empty();
+ if (compareRightValue instanceof SimpleExpressionSegment) {
+ return Optional.of(createEncryptEqualCondition(tableName, expression, compareRightValue));
+ }
+ if (compareRightValue instanceof ListExpression) {
+ return Optional.of(createEncryptLikeCondition(tableName, expression, ((ListExpression) compareRightValue).getItems().get(0)));
+ }
+ return Optional.empty();
+ }
+
+ private EncryptLikeCondition createEncryptLikeCondition(final String tableName, final BinaryOperationExpression expression, final ExpressionSegment compareRightValue) {
+ String columnName = ((ColumnSegment) expression.getLeft()).getIdentifier().getValue();
+ return new EncryptLikeCondition(columnName, tableName, compareRightValue.getStartIndex(), expression.getStopIndex(), compareRightValue);
}
private EncryptEqualCondition createEncryptEqualCondition(final String tableName, final BinaryOperationExpression expression, final ExpressionSegment compareRightValue) {
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/condition/impl/EncryptLikeCondition.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/condition/impl/EncryptLikeCondition.java
new file mode 100644
index 00000000000..010c534d1a8
--- /dev/null
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/condition/impl/EncryptLikeCondition.java
@@ -0,0 +1,89 @@
+/*
+ * 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.encrypt.rewrite.condition.impl;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.ToString;
+import org.apache.shardingsphere.encrypt.rewrite.condition.EncryptCondition;
+import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.ExpressionSegment;
+import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.simple.LiteralExpressionSegment;
+import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+/**
+ * Encrypt condition for like.
+ */
+@Getter
+@EqualsAndHashCode
+@ToString
+public final class EncryptLikeCondition implements EncryptCondition {
+
+ private final String columnName;
+
+ private final String tableName;
+
+ private final int startIndex;
+
+ private final int stopIndex;
+
+ private final Map<Integer, Integer> positionIndexMap = new LinkedHashMap<>();
+
+ private final Map<Integer, Object> positionValueMap = new LinkedHashMap<>();
+
+ public EncryptLikeCondition(final String columnName, final String tableName, final int startIndex, final int stopIndex, final ExpressionSegment expressionSegment) {
+ this.columnName = columnName;
+ this.tableName = tableName;
+ this.startIndex = startIndex;
+ this.stopIndex = stopIndex;
+ putPositionMap(expressionSegment);
+ }
+
+ private void putPositionMap(final ExpressionSegment expressionSegment) {
+ if (expressionSegment instanceof ParameterMarkerExpressionSegment) {
+ positionIndexMap.put(0, ((ParameterMarkerExpressionSegment) expressionSegment).getParameterMarkerIndex());
+ } else if (expressionSegment instanceof LiteralExpressionSegment) {
+ positionValueMap.put(0, ((LiteralExpressionSegment) expressionSegment).getLiterals());
+ }
+ }
+
+ /**
+ * Get values.
+ *
+ * @param parameters SQL parameters
+ * @return values
+ */
+ @Override
+ public List<Object> getValues(final List<Object> parameters) {
+ List<Object> result = new ArrayList<>(positionValueMap.values());
+ for (Entry<Integer, Integer> entry : positionIndexMap.entrySet()) {
+ Object parameter = parameters.get(entry.getValue());
+ if (entry.getKey() < result.size()) {
+ result.add(entry.getKey(), parameter);
+ } else {
+ result.add(parameter);
+ }
+ }
+ return result;
+ }
+}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptAssignmentParameterRewriter.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptAssignmentParameterRewriter.java
index 799dd5e19ac..46748047238 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptAssignmentParameterRewriter.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptAssignmentParameterRewriter.java
@@ -101,6 +101,10 @@ public final class EncryptAssignmentParameterRewriter implements ParameterRewrit
Object assistedQueryValue = encryptRule.getEncryptAssistedQueryValues(databaseName, schemaName, tableName, columnName, Collections.singletonList(originalValue)).iterator().next();
addedParameters.add(assistedQueryValue);
}
+ if (encryptRule.findFuzzyQueryColumn(tableName, columnName).isPresent()) {
+ Object fuzzyValue = encryptRule.getEncryptFuzzyQueryValues(databaseName, schemaName, tableName, columnName, Collections.singletonList(originalValue)).iterator().next();
+ addedParameters.add(fuzzyValue);
+ }
if (encryptRule.findPlainColumn(tableName, columnName).isPresent()) {
addedParameters.add(originalValue);
}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptInsertOnDuplicateKeyUpdateValueParameterRewriter.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptInsertOnDuplicateKeyUpdateValueParameterRewriter.java
index 7a457f00f70..64653a0173a 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptInsertOnDuplicateKeyUpdateValueParameterRewriter.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptInsertOnDuplicateKeyUpdateValueParameterRewriter.java
@@ -82,6 +82,12 @@ public final class EncryptInsertOnDuplicateKeyUpdateValueParameterRewriter imple
Preconditions.checkArgument(assistedColumnName.isPresent(), "Can not find assisted query Column Name");
addedParameters.add(assistedQueryEncryptor.get().encrypt(plainColumnValue, encryptContext));
}
+ Optional<EncryptAlgorithm> fuzzyQueryEncryptor = encryptRule.findFuzzyQueryEncryptor(tableName, encryptLogicColumnName);
+ if (fuzzyQueryEncryptor.isPresent()) {
+ Optional<String> fuzzyColumnName = encryptRule.findFuzzyQueryColumn(tableName, encryptLogicColumnName);
+ Preconditions.checkArgument(fuzzyColumnName.isPresent(), "Can not find assisted query Column Name");
+ addedParameters.add(fuzzyQueryEncryptor.get().encrypt(plainColumnValue, encryptContext));
+ }
if (encryptRule.findPlainColumn(tableName, encryptLogicColumnName).isPresent()) {
addedParameters.add(plainColumnValue);
}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptInsertValueParameterRewriter.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptInsertValueParameterRewriter.java
index 72144d9cc45..93abb7ef31f 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptInsertValueParameterRewriter.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptInsertValueParameterRewriter.java
@@ -67,13 +67,16 @@ public final class EncryptInsertValueParameterRewriter implements ParameterRewri
while (descendingColumnNames.hasNext()) {
String columnName = descendingColumnNames.next();
EncryptContext encryptContext = EncryptContextBuilder.build(databaseName, schemaName, tableName, columnName);
- encryptRule.findEncryptor(tableName, columnName).ifPresent(optional -> encryptInsertValues((GroupedParameterBuilder) parameterBuilder, insertStatementContext, optional,
- encryptRule.findAssistedQueryEncryptor(tableName, columnName).orElse(null), encryptContext));
+ encryptRule.findEncryptor(tableName, columnName).ifPresent(
+ optional -> encryptInsertValues((GroupedParameterBuilder) parameterBuilder, insertStatementContext, optional,
+ encryptRule.findAssistedQueryEncryptor(tableName, columnName).orElse(null),
+ encryptRule.findFuzzyQueryEncryptor(tableName, columnName).orElse(null), encryptContext));
}
}
private void encryptInsertValues(final GroupedParameterBuilder parameterBuilder, final InsertStatementContext insertStatementContext,
- final EncryptAlgorithm<?, ?> encryptAlgorithm, final EncryptAlgorithm<?, ?> assistEncryptAlgorithm, final EncryptContext encryptContext) {
+ final EncryptAlgorithm<?, ?> encryptAlgorithm, final EncryptAlgorithm<?, ?> assistEncryptAlgorithm,
+ final EncryptAlgorithm<?, ?> fuzzyEncryptAlgorithm, final EncryptContext encryptContext) {
int columnIndex = getColumnIndex(parameterBuilder, insertStatementContext, encryptContext.getColumnName());
int count = 0;
for (List<Object> each : insertStatementContext.getGroupedParameters()) {
@@ -84,7 +87,7 @@ public final class EncryptInsertValueParameterRewriter implements ParameterRewri
if (expressionSegment instanceof ParameterMarkerExpressionSegment) {
Object literalValue = insertStatementContext.getInsertValueContexts().get(count).getLiteralValue(columnIndex)
.orElse(null);
- encryptInsertValue(encryptAlgorithm, assistEncryptAlgorithm, parameterIndex, literalValue, standardParameterBuilder, encryptContext);
+ encryptInsertValue(encryptAlgorithm, assistEncryptAlgorithm, fuzzyEncryptAlgorithm, parameterIndex, literalValue, standardParameterBuilder, encryptContext);
}
}
count++;
@@ -103,8 +106,9 @@ public final class EncryptInsertValueParameterRewriter implements ParameterRewri
}
@SuppressWarnings({"rawtypes", "unchecked"})
- private void encryptInsertValue(final EncryptAlgorithm encryptAlgorithm, final EncryptAlgorithm assistEncryptor, final int parameterIndex,
- final Object originalValue, final StandardParameterBuilder parameterBuilder, final EncryptContext encryptContext) {
+ private void encryptInsertValue(final EncryptAlgorithm encryptAlgorithm, final EncryptAlgorithm assistEncryptor, final EncryptAlgorithm fuzzyEncryptor,
+ final int parameterIndex, final Object originalValue, final StandardParameterBuilder parameterBuilder,
+ final EncryptContext encryptContext) {
parameterBuilder.addReplacedParameters(parameterIndex, encryptAlgorithm.encrypt(originalValue, encryptContext));
Collection<Object> addedParameters = new LinkedList<>();
if (null != assistEncryptor) {
@@ -112,6 +116,11 @@ public final class EncryptInsertValueParameterRewriter implements ParameterRewri
Preconditions.checkArgument(assistedColumnName.isPresent(), "Can not find assisted query Column Name");
addedParameters.add(assistEncryptor.encrypt(originalValue, encryptContext));
}
+ if (null != fuzzyEncryptor) {
+ Optional<String> fuzzyColumnName = encryptRule.findFuzzyQueryColumn(encryptContext.getTableName(), encryptContext.getColumnName());
+ Preconditions.checkArgument(fuzzyColumnName.isPresent(), "Can not find fuzzy query Column Name");
+ addedParameters.add(fuzzyEncryptor.encrypt(originalValue, encryptContext));
+ }
if (encryptRule.findPlainColumn(encryptContext.getTableName(), encryptContext.getColumnName()).isPresent()) {
addedParameters.add(originalValue);
}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptPredicateParameterRewriter.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptPredicateParameterRewriter.java
index b5b81bf7416..2df8644ce53 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptPredicateParameterRewriter.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/parameter/rewriter/EncryptPredicateParameterRewriter.java
@@ -21,6 +21,7 @@ import lombok.Setter;
import org.apache.shardingsphere.encrypt.rewrite.aware.DatabaseNameAware;
import org.apache.shardingsphere.encrypt.rewrite.aware.EncryptConditionsAware;
import org.apache.shardingsphere.encrypt.rewrite.condition.EncryptCondition;
+import org.apache.shardingsphere.encrypt.rewrite.condition.impl.EncryptLikeCondition;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
import org.apache.shardingsphere.encrypt.rule.aware.EncryptRuleAware;
import org.apache.shardingsphere.infra.binder.statement.SQLStatementContext;
@@ -66,6 +67,10 @@ public final class EncryptPredicateParameterRewriter implements ParameterRewrite
private List<Object> getEncryptedValues(final String schemaName, final EncryptCondition encryptCondition, final List<Object> originalValues) {
String tableName = encryptCondition.getTableName();
String columnName = encryptCondition.getColumnName();
+ if (encryptCondition instanceof EncryptLikeCondition && encryptRule.findFuzzyQueryColumn(tableName, columnName).isPresent()) {
+ return encryptRule.getEncryptFuzzyQueryValues(databaseName, schemaName, tableName, columnName, originalValues);
+ }
+
return encryptRule.findAssistedQueryColumn(tableName, columnName).isPresent()
? encryptRule.getEncryptAssistedQueryValues(databaseName, schemaName, tableName, columnName, originalValues)
: encryptRule.getEncryptValues(databaseName, schemaName, tableName, columnName, originalValues);
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/AssistQueryAndPlainInsertColumnsTokenGenerator.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/AssistQueryAndPlainInsertColumnsTokenGenerator.java
index 3d6539a208b..f6f72b709b2 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/AssistQueryAndPlainInsertColumnsTokenGenerator.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/AssistQueryAndPlainInsertColumnsTokenGenerator.java
@@ -63,6 +63,7 @@ public final class AssistQueryAndPlainInsertColumnsTokenGenerator implements Col
private List<String> getColumns(final EncryptTable encryptTable, final ColumnSegment columnSegment) {
List<String> result = new LinkedList<>();
encryptTable.findAssistedQueryColumn(columnSegment.getIdentifier().getValue()).ifPresent(result::add);
+ encryptTable.findFuzzyQueryColumn(columnSegment.getIdentifier().getValue()).ifPresent(result::add);
encryptTable.findPlainColumn(columnSegment.getIdentifier().getValue()).ifPresent(result::add);
return result;
}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptAssignmentTokenGenerator.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptAssignmentTokenGenerator.java
index e61bcf167df..8e4c77c115f 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptAssignmentTokenGenerator.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptAssignmentTokenGenerator.java
@@ -98,6 +98,7 @@ public final class EncryptAssignmentTokenGenerator implements CollectionSQLToken
String columnName = assignmentSegment.getColumns().get(0).getIdentifier().getValue();
addCipherColumn(tableName, columnName, result);
addAssistedQueryColumn(tableName, columnName, result);
+ addFuzzyQueryColumn(tableName, columnName, result);
addPlainColumn(tableName, columnName, result);
return result;
}
@@ -110,6 +111,10 @@ public final class EncryptAssignmentTokenGenerator implements CollectionSQLToken
encryptRule.findAssistedQueryColumn(tableName, columnName).ifPresent(token::addColumnName);
}
+ private void addFuzzyQueryColumn(final String tableName, final String columnName, final EncryptParameterAssignmentToken token) {
+ encryptRule.findFuzzyQueryColumn(tableName, columnName).ifPresent(token::addColumnName);
+ }
+
private void addPlainColumn(final String tableName, final String columnName, final EncryptParameterAssignmentToken token) {
encryptRule.findPlainColumn(tableName, columnName).ifPresent(token::addColumnName);
}
@@ -118,6 +123,7 @@ public final class EncryptAssignmentTokenGenerator implements CollectionSQLToken
EncryptLiteralAssignmentToken result = new EncryptLiteralAssignmentToken(assignmentSegment.getColumns().get(0).getStartIndex(), assignmentSegment.getStopIndex());
addCipherAssignment(schemaName, tableName, assignmentSegment, result);
addAssistedQueryAssignment(schemaName, tableName, assignmentSegment, result);
+ addFuzzyAssignment(schemaName, tableName, assignmentSegment, result);
addPlainAssignment(tableName, assignmentSegment, result);
return result;
}
@@ -139,6 +145,16 @@ public final class EncryptAssignmentTokenGenerator implements CollectionSQLToken
}
}
+ private void addFuzzyAssignment(final String schemaName, final String tableName, final AssignmentSegment assignmentSegment, final EncryptLiteralAssignmentToken token) {
+ Object originalValue = ((LiteralExpressionSegment) assignmentSegment.getValue()).getLiterals();
+ Optional<String> assistedQueryColumn = encryptRule.findFuzzyQueryColumn(tableName, assignmentSegment.getColumns().get(0).getIdentifier().getValue());
+ if (assistedQueryColumn.isPresent()) {
+ Object assistedQueryValue = encryptRule.getEncryptFuzzyQueryValues(databaseName, schemaName,
+ tableName, assignmentSegment.getColumns().get(0).getIdentifier().getValue(), Collections.singletonList(originalValue)).iterator().next();
+ token.addAssignment(assistedQueryColumn.get(), assistedQueryValue);
+ }
+ }
+
private void addPlainAssignment(final String tableName, final AssignmentSegment assignmentSegment, final EncryptLiteralAssignmentToken token) {
Object originalValue = ((LiteralExpressionSegment) assignmentSegment.getValue()).getLiterals();
encryptRule.findPlainColumn(tableName, assignmentSegment.getColumns().get(0).getIdentifier().getValue()).ifPresent(optional -> token.addAssignment(optional, originalValue));
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptCreateTableTokenGenerator.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptCreateTableTokenGenerator.java
index a2089afb9c8..465bc9b410e 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptCreateTableTokenGenerator.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptCreateTableTokenGenerator.java
@@ -75,6 +75,7 @@ public final class EncryptCreateTableTokenGenerator implements CollectionSQLToke
result.add(new RemoveToken(column.getStartIndex(), columnStopIndex));
result.add(getCipherColumnToken(tableName, columnName, column, columnStopIndex));
getAssistedQueryColumnToken(tableName, columnName, column, columnStopIndex, lastColumn).ifPresent(result::add);
+ getFuzzyQueryColumnToken(tableName, columnName, column, columnStopIndex, lastColumn).ifPresent(result::add);
getPlainColumnToken(tableName, columnName, column, columnStopIndex, lastColumn).ifPresent(result::add);
return result;
}
@@ -89,6 +90,12 @@ public final class EncryptCreateTableTokenGenerator implements CollectionSQLToke
return assistedQueryColumn.map(optional -> new SubstitutableColumnNameToken(stopIndex + 1, column.getColumnName().getStopIndex(), getColumnProjections(optional), lastColumn));
}
+ private Optional<? extends SQLToken> getFuzzyQueryColumnToken(final String tableName, final String columnName, final ColumnDefinitionSegment column,
+ final int stopIndex, final boolean lastColumn) {
+ Optional<String> fuzzyQueryColumn = encryptRule.findFuzzyQueryColumn(tableName, columnName);
+ return fuzzyQueryColumn.map(optional -> new SubstitutableColumnNameToken(stopIndex + 1, column.getColumnName().getStopIndex(), getColumnProjections(optional), lastColumn));
+ }
+
private Optional<? extends SQLToken> getPlainColumnToken(final String tableName, final String columnName, final ColumnDefinitionSegment column,
final int stopIndex, final boolean lastColumn) {
Optional<String> plainColumn = encryptRule.findPlainColumn(tableName, columnName);
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertOnUpdateTokenGenerator.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertOnUpdateTokenGenerator.java
index aa3a1999e9f..5e23d66fa0e 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertOnUpdateTokenGenerator.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertOnUpdateTokenGenerator.java
@@ -108,6 +108,7 @@ public final class EncryptInsertOnUpdateTokenGenerator implements CollectionSQLT
String columnName = assignmentSegment.getColumns().get(0).getIdentifier().getValue();
addCipherColumn(tableName, columnName, result);
addAssistedQueryColumn(tableName, columnName, result);
+ addFuzzyQueryColumn(tableName, columnName, result);
addPlainColumn(tableName, columnName, result);
return result;
}
@@ -116,6 +117,7 @@ public final class EncryptInsertOnUpdateTokenGenerator implements CollectionSQLT
EncryptLiteralAssignmentToken result = new EncryptLiteralAssignmentToken(assignmentSegment.getColumns().get(0).getStartIndex(), assignmentSegment.getStopIndex());
addCipherAssignment(schemaName, tableName, assignmentSegment, result);
addAssistedQueryAssignment(schemaName, tableName, assignmentSegment, result);
+ addFuzzyAssignment(schemaName, tableName, assignmentSegment, result);
addPlainAssignment(tableName, assignmentSegment, result);
return result;
}
@@ -142,6 +144,13 @@ public final class EncryptInsertOnUpdateTokenGenerator implements CollectionSQLT
} else if (assistedQueryColumn.isPresent() != valueAssistedQueryColumn.isPresent()) {
throw new UnsupportedEncryptSQLException(String.format("%s=VALUES(%s)", column, valueColumn));
}
+ Optional<String> fuzzyQueryColumn = encryptRule.findFuzzyQueryColumn(tableName, column);
+ Optional<String> valueFuzzyQueryColumn = encryptRule.findFuzzyQueryColumn(tableName, valueColumn);
+ if (fuzzyQueryColumn.isPresent() && valueFuzzyQueryColumn.isPresent()) {
+ result.addAssignment(fuzzyQueryColumn.get(), "VALUES(" + valueFuzzyQueryColumn.get() + ")");
+ } else if (fuzzyQueryColumn.isPresent() != valueFuzzyQueryColumn.isPresent()) {
+ throw new UnsupportedEncryptSQLException(String.format("%s=VALUES(%s)", column, valueColumn));
+ }
Optional<String> plainColumn = encryptRule.findPlainColumn(tableName, column);
Optional<String> valuePlainColumn = encryptRule.findPlainColumn(tableName, valueColumn);
if (plainColumn.isPresent() && valuePlainColumn.isPresent()) {
@@ -163,6 +172,10 @@ public final class EncryptInsertOnUpdateTokenGenerator implements CollectionSQLT
encryptRule.findAssistedQueryColumn(tableName, columnName).ifPresent(token::addColumnName);
}
+ private void addFuzzyQueryColumn(final String tableName, final String columnName, final EncryptParameterAssignmentToken token) {
+ encryptRule.findFuzzyQueryColumn(tableName, columnName).ifPresent(token::addColumnName);
+ }
+
private void addPlainColumn(final String tableName, final String columnName, final EncryptParameterAssignmentToken token) {
encryptRule.findPlainColumn(tableName, columnName).ifPresent(token::addColumnName);
}
@@ -184,6 +197,16 @@ public final class EncryptInsertOnUpdateTokenGenerator implements CollectionSQLT
});
}
+ private void addFuzzyAssignment(final String schemaName, final String tableName, final AssignmentSegment assignmentSegment, final EncryptLiteralAssignmentToken token) {
+ encryptRule.findFuzzyQueryColumn(tableName, assignmentSegment.getColumns().get(0).getIdentifier().getValue()).ifPresent(optional -> {
+ Object originalValue = ((LiteralExpressionSegment) assignmentSegment.getValue()).getLiterals();
+ Object fuzzyValue = encryptRule
+ .getEncryptFuzzyQueryValues(databaseName, schemaName, tableName, assignmentSegment.getColumns().get(0).getIdentifier().getValue(), Collections.singletonList(originalValue))
+ .iterator().next();
+ token.addAssignment(optional, fuzzyValue);
+ });
+ }
+
private void addPlainAssignment(final String tableName, final AssignmentSegment assignmentSegment, final EncryptLiteralAssignmentToken token) {
Object originalValue = ((LiteralExpressionSegment) assignmentSegment.getValue()).getLiterals();
encryptRule.findPlainColumn(tableName, assignmentSegment.getColumns().get(0).getIdentifier().getValue()).ifPresent(optional -> token.addAssignment(optional, originalValue));
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertValuesTokenGenerator.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertValuesTokenGenerator.java
index ab60dd8fafd..0015ab98731 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertValuesTokenGenerator.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertValuesTokenGenerator.java
@@ -136,8 +136,13 @@ public final class EncryptInsertValuesTokenGenerator implements OptionalSQLToken
Object originalValue = insertValueContext.getLiteralValue(columnIndex).orElse(null);
EncryptContext encryptContext = EncryptContextBuilder.build(databaseName, schemaName, tableName, columnName);
addPlainColumn(insertValueToken, columnIndex, encryptContext, insertValueContext, originalValue);
+ int indexDelta = 1;
if (encryptRule.findAssistedQueryEncryptor(tableName, columnName).isPresent()) {
addAssistedQueryColumn(insertValueToken, encryptRule.findAssistedQueryEncryptor(tableName, columnName).get(), columnIndex, encryptContext, insertValueContext, originalValue);
+ indexDelta = indexDelta + 1;
+ }
+ if (encryptRule.findFuzzyQueryEncryptor(tableName, columnName).isPresent()) {
+ addFuzzyQueryColumn(insertValueToken, encryptRule.findFuzzyQueryEncryptor(tableName, columnName).get(), columnIndex, encryptContext, insertValueContext, originalValue, indexDelta);
}
setCipherColumn(insertValueToken, encryptor.get(), columnIndex, encryptContext, insertValueContext.getValueExpressions().get(columnIndex), originalValue);
}
@@ -165,6 +170,17 @@ public final class EncryptInsertValuesTokenGenerator implements OptionalSQLToken
}
}
+ private void addFuzzyQueryColumn(final InsertValue insertValueToken, final EncryptAlgorithm encryptAlgorithm, final int columnIndex,
+ final EncryptContext encryptContext, final InsertValueContext insertValueContext,
+ final Object originalValue, final int indexDelta) {
+ if (encryptRule.findFuzzyQueryColumn(encryptContext.getTableName(), encryptContext.getColumnName()).isPresent()) {
+ DerivedSimpleExpressionSegment derivedExpressionSegment = isAddLiteralExpressionSegment(insertValueContext, columnIndex)
+ ? new DerivedLiteralExpressionSegment(encryptAlgorithm.encrypt(originalValue, encryptContext))
+ : new DerivedParameterMarkerExpressionSegment(getParameterIndexCount(insertValueToken));
+ insertValueToken.getValues().add(columnIndex + indexDelta, derivedExpressionSegment);
+ }
+ }
+
private boolean isAddLiteralExpressionSegment(final InsertValueContext insertValueContext, final int columnIndex) {
return insertValueContext.getParameters().isEmpty()
|| insertValueContext.getValueExpressions().get(columnIndex) instanceof LiteralExpressionSegment;
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptPredicateColumnTokenGenerator.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptPredicateColumnTokenGenerator.java
index fb20efda7ca..37cb3354495 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptPredicateColumnTokenGenerator.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptPredicateColumnTokenGenerator.java
@@ -18,6 +18,7 @@
package org.apache.shardingsphere.encrypt.rewrite.token.generator;
import lombok.Setter;
+import org.apache.shardingsphere.encrypt.exception.syntax.UnsupportedEncryptSQLException;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
import org.apache.shardingsphere.encrypt.rule.EncryptTable;
import org.apache.shardingsphere.encrypt.rule.aware.EncryptRuleAware;
@@ -30,6 +31,11 @@ import org.apache.shardingsphere.infra.rewrite.sql.token.generator.CollectionSQL
import org.apache.shardingsphere.infra.rewrite.sql.token.generator.aware.SchemaMetaDataAware;
import org.apache.shardingsphere.infra.rewrite.sql.token.pojo.generic.SubstitutableColumnNameToken;
import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.column.ColumnSegment;
+import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.BinaryOperationExpression;
+import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.ExpressionSegment;
+import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.predicate.AndPredicate;
+import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.predicate.WhereSegment;
+import org.apache.shardingsphere.sql.parser.sql.common.util.ExpressionExtractUtil;
import java.util.Collection;
import java.util.Collections;
@@ -56,14 +62,22 @@ public final class EncryptPredicateColumnTokenGenerator implements CollectionSQL
@Override
public Collection<SubstitutableColumnNameToken> generateSQLTokens(final SQLStatementContext<?> sqlStatementContext) {
- Collection<ColumnSegment> columnSegments = sqlStatementContext instanceof WhereAvailable ? ((WhereAvailable) sqlStatementContext).getColumnSegments() : Collections.emptyList();
+ Collection<ColumnSegment> columnSegments = Collections.emptyList();
+ Collection<WhereSegment> whereSegments = Collections.emptyList();
+ if (sqlStatementContext instanceof WhereAvailable) {
+ columnSegments = ((WhereAvailable) sqlStatementContext).getColumnSegments();
+ whereSegments = ((WhereAvailable) sqlStatementContext).getWhereSegments();
+ }
String defaultSchema = DatabaseTypeEngine.getDefaultSchemaName(sqlStatementContext.getDatabaseType(), databaseName);
ShardingSphereSchema schema = sqlStatementContext.getTablesContext().getSchemaName().map(schemas::get).orElseGet(() -> schemas.get(defaultSchema));
Map<String, String> columnExpressionTableNames = sqlStatementContext.getTablesContext().findTableNamesByColumnSegment(columnSegments, schema);
- return generateSQLTokens(columnSegments, columnExpressionTableNames);
+ return generateSQLTokens(columnSegments, columnExpressionTableNames, whereSegments);
}
- private Collection<SubstitutableColumnNameToken> generateSQLTokens(final Collection<ColumnSegment> columnSegments, final Map<String, String> columnExpressionTableNames) {
+ private Collection<SubstitutableColumnNameToken> generateSQLTokens(
+ final Collection<ColumnSegment> columnSegments,
+ final Map<String, String> columnExpressionTableNames,
+ final Collection<WhereSegment> whereSegments) {
Collection<SubstitutableColumnNameToken> result = new LinkedHashSet<>();
for (ColumnSegment each : columnSegments) {
String tableName = Optional.ofNullable(columnExpressionTableNames.get(each.getExpression())).orElse("");
@@ -81,6 +95,19 @@ public final class EncryptPredicateColumnTokenGenerator implements CollectionSQL
continue;
}
}
+ BinaryOperationExpression boe = findBinaryOperationExpression(whereSegments, each);
+ if (boe != null && boe.getOperator().equalsIgnoreCase("LIKE")) {
+ Optional<String> fuzzyQueryColumn = encryptTable.get()
+ .findFuzzyQueryColumn(each.getIdentifier().getValue());
+ if (!fuzzyQueryColumn.isPresent()) {
+ throw new UnsupportedEncryptSQLException("LIKE");
+ } else {
+ result.add(new SubstitutableColumnNameToken(startIndex,
+ stopIndex, createColumnProjections(fuzzyQueryColumn.get())));
+ continue;
+ }
+ }
+
Optional<String> assistedQueryColumn = encryptTable.get().findAssistedQueryColumn(each.getIdentifier().getValue());
SubstitutableColumnNameToken encryptColumnNameToken = assistedQueryColumn.map(columnName -> new SubstitutableColumnNameToken(startIndex, stopIndex, createColumnProjections(columnName)))
.orElseGet(() -> new SubstitutableColumnNameToken(startIndex, stopIndex, createColumnProjections(encryptTable.get().getCipherColumn(each.getIdentifier().getValue()))));
@@ -89,6 +116,36 @@ public final class EncryptPredicateColumnTokenGenerator implements CollectionSQL
return result;
}
+ private BinaryOperationExpression findBinaryOperationExpression(
+ final Collection<WhereSegment> whereSegments,
+ final ColumnSegment columnSegment) {
+ for (WhereSegment whereSegment : whereSegments) {
+ Collection<AndPredicate> andPredicates =
+ ExpressionExtractUtil.getAndPredicates(whereSegment.getExpr());
+ for (AndPredicate andPredicate : andPredicates) {
+ for (ExpressionSegment predicate : andPredicate.getPredicates()) {
+ if (predicate instanceof BinaryOperationExpression) {
+ BinaryOperationExpression boe = (BinaryOperationExpression) predicate;
+ if (columnMatch(columnSegment, boe.getLeft())) {
+ return boe;
+ }
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ private boolean columnMatch(final ColumnSegment columnSegment, final ExpressionSegment left) {
+ if (left instanceof ColumnSegment) {
+ ColumnSegment leftCol = (ColumnSegment) left;
+ if (leftCol.getStartIndex() == columnSegment.getStartIndex() && left.getStopIndex() == columnSegment.getStopIndex()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
private Collection<ColumnProjection> createColumnProjections(final String columnName) {
return Collections.singletonList(new ColumnProjection(null, columnName, null));
}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptPredicateRightValueTokenGenerator.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptPredicateRightValueTokenGenerator.java
index 5be3fa299fd..35eaa848d7f 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptPredicateRightValueTokenGenerator.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptPredicateRightValueTokenGenerator.java
@@ -18,10 +18,12 @@
package org.apache.shardingsphere.encrypt.rewrite.token.generator;
import lombok.Setter;
+import org.apache.shardingsphere.encrypt.exception.syntax.UnsupportedEncryptSQLException;
import org.apache.shardingsphere.encrypt.rewrite.aware.DatabaseNameAware;
import org.apache.shardingsphere.encrypt.rewrite.aware.EncryptConditionsAware;
import org.apache.shardingsphere.encrypt.rewrite.condition.EncryptCondition;
import org.apache.shardingsphere.encrypt.rewrite.condition.impl.EncryptInCondition;
+import org.apache.shardingsphere.encrypt.rewrite.condition.impl.EncryptLikeCondition;
import org.apache.shardingsphere.encrypt.rewrite.token.pojo.EncryptPredicateEqualRightValueToken;
import org.apache.shardingsphere.encrypt.rewrite.token.pojo.EncryptPredicateInRightValueToken;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
@@ -94,6 +96,14 @@ public final class EncryptPredicateRightValueTokenGenerator
}
private List<Object> getEncryptedValues(final String schemaName, final EncryptCondition encryptCondition, final List<Object> originalValues) {
+ if (encryptCondition instanceof EncryptLikeCondition) {
+ Optional<String> fuzzyQueryColumn = encryptRule.findFuzzyQueryColumn(encryptCondition.getTableName(), encryptCondition.getColumnName());
+ if (!fuzzyQueryColumn.isPresent()) {
+ throw new UnsupportedEncryptSQLException("LIKE");
+ } else {
+ return encryptRule.getEncryptFuzzyQueryValues(databaseName, schemaName, encryptCondition.getTableName(), encryptCondition.getColumnName(), originalValues);
+ }
+ }
Optional<String> assistedQueryColumn = encryptRule.findAssistedQueryColumn(encryptCondition.getTableName(), encryptCondition.getColumnName());
return assistedQueryColumn.isPresent()
? encryptRule.getEncryptAssistedQueryValues(databaseName, schemaName, encryptCondition.getTableName(), encryptCondition.getColumnName(), originalValues)
diff --git a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/impl/EncryptCreateTableTokenGeneratorTest.java b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/impl/EncryptCreateTableTokenGeneratorTest.java
index 20fb639e58c..f3a597238ac 100644
--- a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/impl/EncryptCreateTableTokenGeneratorTest.java
+++ b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/impl/EncryptCreateTableTokenGeneratorTest.java
@@ -60,7 +60,7 @@ public final class EncryptCreateTableTokenGeneratorTest {
@Test
public void assertGenerateSQLTokens() {
Collection<SQLToken> sqlTokens = generator.generateSQLTokens(buildCreateTableStatementContext());
- assertThat(sqlTokens.size(), is(4));
+ assertThat(sqlTokens.size(), is(5));
Iterator<SQLToken> iterator = sqlTokens.iterator();
assertThat(iterator.next(), instanceOf(RemoveToken.class));
SubstitutableColumnNameToken cipherToken = (SubstitutableColumnNameToken) iterator.next();
@@ -71,6 +71,10 @@ public final class EncryptCreateTableTokenGeneratorTest {
assertThat(assistedToken.toString(mock(RouteUnit.class)), is(", assisted_certificate_number"));
assertThat(assistedToken.getStartIndex(), is(79));
assertThat(assistedToken.getStopIndex(), is(42));
+ SubstitutableColumnNameToken fuzzyToken = (SubstitutableColumnNameToken) iterator.next();
+ assertThat(fuzzyToken.toString(mock(RouteUnit.class)), is(", fuzzy_certificate_number"));
+ assertThat(fuzzyToken.getStartIndex(), is(79));
+ assertThat(fuzzyToken.getStopIndex(), is(42));
SubstitutableColumnNameToken plainToken = (SubstitutableColumnNameToken) iterator.next();
assertThat(plainToken.toString(mock(RouteUnit.class)), is(", certificate_number_plain"));
assertThat(plainToken.getStartIndex(), is(79));
diff --git a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertValuesTokenGeneratorTest.java b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertValuesTokenGeneratorTest.java
index 6feb3ea71e7..061b66af34c 100644
--- a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertValuesTokenGeneratorTest.java
+++ b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptInsertValuesTokenGeneratorTest.java
@@ -40,27 +40,17 @@ public final class EncryptInsertValuesTokenGeneratorTest extends EncryptGenerato
EncryptInsertValuesTokenGenerator encryptInsertValuesTokenGenerator = new EncryptInsertValuesTokenGenerator();
encryptInsertValuesTokenGenerator.setEncryptRule(createEncryptRule());
encryptInsertValuesTokenGenerator.setPreviousSQLTokens(Collections.emptyList());
- encryptInsertValuesTokenGenerator.setDatabaseName("encrypt_db");
- assertThat(encryptInsertValuesTokenGenerator.generateSQLToken(createInsertStatementContext(Arrays.asList(1, "Tom", 0, "123456"))).toString(), is("(?, ?, ?, ?, ?, ?)"));
- }
-
- @Test
- public void assertGenerateSQLTokenFromPreviousSQLTokensWithNullField() {
- EncryptInsertValuesTokenGenerator encryptInsertValuesTokenGenerator = new EncryptInsertValuesTokenGenerator();
- encryptInsertValuesTokenGenerator.setDatabaseName("encrypt_db");
- encryptInsertValuesTokenGenerator.setEncryptRule(createEncryptRule());
- encryptInsertValuesTokenGenerator.setPreviousSQLTokens(getPreviousSQLTokens());
- encryptInsertValuesTokenGenerator.setDatabaseName("encrypt_db");
- assertThat(encryptInsertValuesTokenGenerator.generateSQLToken(createInsertStatementContext(Arrays.asList(1, "Tom", 0, null))).toString(), is("(?, ?, ?, ?, ?, ?)"));
+ encryptInsertValuesTokenGenerator.setDatabaseName("db_schema");
+ assertThat(encryptInsertValuesTokenGenerator.generateSQLToken(createInsertStatementContext(Arrays.asList(1, "Tom", 0, "123456"))).toString(), is("(?, ?, ?, ?, ?, ?, ?)"));
}
@Test
public void assertGenerateSQLTokenFromPreviousSQLTokens() {
EncryptInsertValuesTokenGenerator encryptInsertValuesTokenGenerator = new EncryptInsertValuesTokenGenerator();
- encryptInsertValuesTokenGenerator.setDatabaseName("encrypt_db");
+ encryptInsertValuesTokenGenerator.setDatabaseName("db-001");
encryptInsertValuesTokenGenerator.setEncryptRule(createEncryptRule());
encryptInsertValuesTokenGenerator.setPreviousSQLTokens(getPreviousSQLTokens());
- encryptInsertValuesTokenGenerator.setDatabaseName("encrypt_db");
- assertThat(encryptInsertValuesTokenGenerator.generateSQLToken(createInsertStatementContext(Arrays.asList(1, "Tom", 0, "123456"))).toString(), is("(?, ?, ?, ?, ?, ?)"));
+ encryptInsertValuesTokenGenerator.setDatabaseName("db_schema");
+ assertThat(encryptInsertValuesTokenGenerator.generateSQLToken(createInsertStatementContext(Arrays.asList(1, "Tom", 0, "123456"))).toString(), is("(?, ?, ?, ?, ?, ?, ?)"));
}
}
diff --git a/test/parser/src/main/resources/case/rdl/alter.xml b/test/parser/src/main/resources/case/rdl/alter.xml
index 01add488e9b..a6999c7941d 100644
--- a/test/parser/src/main/resources/case/rdl/alter.xml
+++ b/test/parser/src/main/resources/case/rdl/alter.xml
@@ -205,6 +205,22 @@
</rule>
</alter-encrypt-rule>
+ <alter-encrypt-rule sql-case-id="alter-encrypt-rule-with-fuzzy-query-column">
+ <rule name="t_encrypt">
+ <column name="user_id" plain-column="user_plain" cipher-column="user_cipher" fuzzy-query-column="fuzzy_column">
+ <encryptor algorithm-name="AES">
+ <properties>
+ <property key="aes-key-value" value="123456abc"/>
+ </properties>
+ </encryptor>
+ <fuzzy-query-encryptor algorithm-name="CHAR_DIGEST_FUZZY"/>
+ </column>
+ <column name="order_id" cipher-column="order_cipher">
+ <encryptor algorithm-name="MD5"/>
+ </column>
+ </rule>
+ </alter-encrypt-rule>
+
<alter-encrypt-rule sql-case-id="alter-encrypt-rule-with-query-with-cipher-column">
<rule name="t_encrypt" queryWithCipherColumn="false">
<column name="user_id" plain-column="user_plain" cipher-column="user_cipher">
diff --git a/test/parser/src/main/resources/case/rdl/create.xml b/test/parser/src/main/resources/case/rdl/create.xml
index 65690ecbb2d..c827d790329 100644
--- a/test/parser/src/main/resources/case/rdl/create.xml
+++ b/test/parser/src/main/resources/case/rdl/create.xml
@@ -387,6 +387,22 @@
</rule>
</create-encrypt-rule>
+ <create-encrypt-rule sql-case-id="create-encrypt-rule-with-fuzzy-query-column">
+ <rule name="t_encrypt">
+ <column name="user_id" plain-column="user_plain" cipher-column="user_cipher" fuzzy-query-column="fuzzy_column">
+ <encryptor algorithm-name="AES">
+ <properties>
+ <property key="aes-key-value" value="123456abc"/>
+ </properties>
+ </encryptor>
+ <fuzzy-query-encryptor algorithm-name="CHAR_DIGEST_FUZZY" />
+ </column>
+ <column name="order_id" cipher-column="order_cipher">
+ <encryptor algorithm-name="MD5"/>
+ </column>
+ </rule>
+ </create-encrypt-rule>
+
<create-encrypt-rule sql-case-id="create-encrypt-rule-with-query-with-cipher-column">
<rule name="encrypt" queryWithCipherColumn="false">
<column name="user_id" plain-column="user_plain" cipher-column="user_cipher">
diff --git a/test/parser/src/main/resources/sql/supported/rdl/alter.xml b/test/parser/src/main/resources/sql/supported/rdl/alter.xml
index 9bb93672b9c..07645b428d0 100644
--- a/test/parser/src/main/resources/sql/supported/rdl/alter.xml
+++ b/test/parser/src/main/resources/sql/supported/rdl/alter.xml
@@ -30,6 +30,7 @@
<distsql-case id="alter-database-discovery-definition-rule" value="ALTER DB_DISCOVERY RULE ha_group_0 (STORAGE_UNITS(ds_0,ds_1), TYPE(NAME='mgr',PROPERTIES('groupName'='92504d5b-6dec')),HEARTBEAT(PROPERTIES('keepAliveCron'='0/5 * * * * ?'))), ha_group_1 (STORAGE_UNITS(ds_2,ds_3), TYPE(NAME='mgr2',PROPERTIES('groupName'='92504d5b-6dec-2')),HEARTBEAT(PROPERTIES('keepAliveCron'='0/6 * * * * ?')))" />
<distsql-case id="alter-encrypt-rule" value="ALTER ENCRYPT RULE t_encrypt (RESOURCE=ds_1, COLUMNS((NAME=user_id,PLAIN=user_plain,CIPHER=user_cipher,TYPE(NAME='AES',PROPERTIES('aes-key-value'='123456abc'))), (NAME=order_id, CIPHER =order_cipher,TYPE(NAME='MD5'))))" />
<distsql-case id="alter-encrypt-rule-with-assisted-query-column" value="ALTER ENCRYPT RULE t_encrypt (RESOURCE=ds_1, COLUMNS((NAME=user_id,PLAIN=user_plain,CIPHER=user_cipher,ASSISTED_QUERY_COLUMN=assisted_column, TYPE(NAME='AES',PROPERTIES('aes-key-value'='123456abc')), TYPE(NAME='MD5')), (NAME=order_id, CIPHER =order_cipher,TYPE(NAME='MD5'))))" />
+ <distsql-case id="alter-encrypt-rule-with-fuzzy-query-column" value="ALTER ENCRYPT RULE t_encrypt (RESOURCE=ds_1, COLUMNS((NAME=user_id,PLAIN=user_plain,CIPHER=user_cipher,FUZZY_QUERY_COLUMN=fuzzy_column, TYPE(NAME='AES',PROPERTIES('aes-key-value'='123456abc')), TYPE(NAME='CHAR_DIGEST_FUZZY')), (NAME=order_id, CIPHER =order_cipher,TYPE(NAME='MD5'))))" />
<distsql-case id="alter-encrypt-rule-with-query-with-cipher-column" value="ALTER ENCRYPT RULE t_encrypt (RESOURCE=ds_1, COLUMNS((NAME=user_id,PLAIN=user_plain,CIPHER=user_cipher, TYPE(NAME='AES',PROPERTIES('aes-key-value'='123456abc'))), (NAME=order_id, CIPHER =order_cipher,TYPE(NAME='MD5'))), QUERY_WITH_CIPHER_COLUMN=false)" />
<distsql-case id="alter-default-shadow-algorithm" value="ALTER DEFAULT SHADOW ALGORITHM TYPE(NAME='SIMPLE_HINT', PROPERTIES('shadow'='true', 'foo'='bar'))" />
<distsql-case id="alter-shadow-rule" value="ALTER SHADOW RULE shadow_rule(SOURCE=demo_ds,SHADOW=demo_ds_shadow,t_order(TYPE(NAME='REGEX_MATCH',PROPERTIES('operation'='insert','column'='user_id','regex'='[1]')),TYPE(NAME='SIMPLE_HINT',PROPERTIES('shadow'='true','foo'='bar'))))" />
diff --git a/test/parser/src/main/resources/sql/supported/rdl/create.xml b/test/parser/src/main/resources/sql/supported/rdl/create.xml
index f68c0e2f80c..f904e40fbc5 100644
--- a/test/parser/src/main/resources/sql/supported/rdl/create.xml
+++ b/test/parser/src/main/resources/sql/supported/rdl/create.xml
@@ -36,6 +36,7 @@
<distsql-case id="create-database-discovery-definition-rule" value="CREATE DB_DISCOVERY RULE ha_group_0 (STORAGE_UNITS(ds_0,ds_1), TYPE(NAME='mgr',PROPERTIES('groupName'='92504d5b-6dec')),HEARTBEAT(PROPERTIES('keepAliveCron'='0/5 * * * * ?'))), ha_group_1 (STORAGE_UNITS(ds_2,ds_3), TYPE(NAME='mgr2',PROPERTIES('groupName'='92504d5b-6dec-2')),HEARTBEAT(PROPERTIES('keepAliveCron'='0/6 * * * * ?')))" />
<distsql-case id="create-encrypt-rule" value="CREATE ENCRYPT RULE t_encrypt (RESOURCE=ds_1, COLUMNS((NAME=user_id,PLAIN=user_plain,CIPHER=user_cipher,TYPE(NAME='AES',PROPERTIES('aes-key-value'='123456abc'))), (NAME=order_id, CIPHER =order_cipher,TYPE(NAME='MD5'))))" />
<distsql-case id="create-encrypt-rule-with-assisted-query-column" value="CREATE ENCRYPT RULE t_encrypt (RESOURCE=ds_1, COLUMNS((NAME=user_id,PLAIN=user_plain,CIPHER=user_cipher,ASSISTED_QUERY_COLUMN=assisted_column, TYPE(NAME='AES',PROPERTIES('aes-key-value'='123456abc')), TYPE(NAME='MD5')), (NAME=order_id, CIPHER =order_cipher,TYPE(NAME='MD5'))))" />
+ <distsql-case id="create-encrypt-rule-with-fuzzy-query-column" value="CREATE ENCRYPT RULE t_encrypt (RESOURCE=ds_1, COLUMNS((NAME=user_id,PLAIN=user_plain,CIPHER=user_cipher,FUZZY_QUERY_COLUMN=fuzzy_column, TYPE(NAME='AES',PROPERTIES('aes-key-value'='123456abc')), TYPE(NAME='CHAR_DIGEST_FUZZY')), (NAME=order_id, CIPHER =order_cipher,TYPE(NAME='MD5'))))" />
<distsql-case id="create-shadow-rule" value="CREATE SHADOW RULE shadow_rule(SOURCE=demo_ds,SHADOW=demo_ds_shadow,t_order(TYPE(NAME='REGEX_MATCH',PROPERTIES('operation'='insert','column'='user_id','regex'='[1]')),TYPE(NAME='SIMPLE_HINT',PROPERTIES('shadow'='true','foo'='bar'))))" />
<distsql-case id="create-default-sharding-table-strategy-with-lower-case" value="create default sharding table strategy(type='standard', sharding_column=order_id, SHARDING_ALGORITHM(TYPE(NAME='INLINE',PROPERTIES('algorithm-expression'='t_order_${order_id % 2}'))))" />
<distsql-case id="create-default-sharding-database-strategy" value="CREATE DEFAULT SHARDING DATABASE STRATEGY(TYPE='STANDARD', SHARDING_COLUMN=ORDER_ID, SHARDING_ALGORITHM(TYPE(NAME='INLINE',PROPERTIES('algorithm-expression'='ms_group_${order_id % 2}'))))" />
diff --git a/test/rewrite/src/test/java/org/apache/shardingsphere/sharding/rewrite/fixture/encrypt/RewriteQueryFuzzyEncryptAlgorithmFixture.java b/test/rewrite/src/test/java/org/apache/shardingsphere/sharding/rewrite/fixture/encrypt/RewriteQueryFuzzyEncryptAlgorithmFixture.java
new file mode 100644
index 00000000000..58b2ef69fa9
--- /dev/null
+++ b/test/rewrite/src/test/java/org/apache/shardingsphere/sharding/rewrite/fixture/encrypt/RewriteQueryFuzzyEncryptAlgorithmFixture.java
@@ -0,0 +1,53 @@
+/*
+ * 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.sharding.rewrite.fixture.encrypt;
+
+import lombok.Getter;
+import org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm;
+import org.apache.shardingsphere.encrypt.spi.context.EncryptContext;
+
+import java.util.Properties;
+
+@Getter
+public final class RewriteQueryFuzzyEncryptAlgorithmFixture implements EncryptAlgorithm<Object, String> {
+
+ private Properties props;
+
+ @Override
+ public void init(final Properties props) {
+ this.props = props;
+ }
+
+ @Override
+ public String encrypt(final Object plainValue, final EncryptContext encryptContext) {
+ if (null == plainValue) {
+ return null;
+ }
+ return "fuzzy_query_" + plainValue;
+ }
+
+ @Override
+ public Object decrypt(final String cipherValue, final EncryptContext encryptContext) {
+ return cipherValue;
+ }
+
+ @Override
+ public String getType() {
+ return "REWRITE.FUZZY_QUERY.FIXTURE";
+ }
+}
diff --git a/test/rewrite/src/test/resources/META-INF/services/org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm b/test/rewrite/src/test/resources/META-INF/services/org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm
index b76b0ccee2f..ba101bfc5b6 100644
--- a/test/rewrite/src/test/resources/META-INF/services/org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm
+++ b/test/rewrite/src/test/resources/META-INF/services/org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm
@@ -18,3 +18,4 @@
org.apache.shardingsphere.sharding.rewrite.fixture.encrypt.RewriteNormalEncryptAlgorithmFixture
org.apache.shardingsphere.sharding.rewrite.fixture.encrypt.RewriteSchemaMetaDataAwareEncryptAlgorithmFixture
org.apache.shardingsphere.sharding.rewrite.fixture.encrypt.RewriteQueryAssistedEncryptAlgorithmFixture
+org.apache.shardingsphere.sharding.rewrite.fixture.encrypt.RewriteQueryFuzzyEncryptAlgorithmFixture
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/ddl/create/create-table.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/ddl/create/create-table.xml
index 86f49751c3c..3bf3868da9a 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/ddl/create/create-table.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/ddl/create/create-table.xml
@@ -19,11 +19,11 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="create_table_for_cipher" db-types="MySQL">
<input sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`))" />
- <output sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', cipher_password VARCHAR(255) NOT NULL DEFAULT '', assisted_query_password VARCHAR(255) NOT NULL DEFAULT '', plain_password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`))" />
+ <output sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', cipher_password VARCHAR(255) NOT NULL DEFAULT '', assisted_query_password VARCHAR(255) NOT NULL DEFAULT '', fuzzy_query_password VARCHAR(255) NOT NULL DEFAULT '', plain_password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`))" />
</rewrite-assertion>
<rewrite-assertion id="create_table_with_index_for_cipher" db-types="MySQL">
<input sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`), KEY `t_account_bak_amount_idx` (`amount`))" />
- <output sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', cipher_password VARCHAR(255) NOT NULL DEFAULT '', assisted_query_password VARCHAR(255) NOT NULL DEFAULT '', plain_password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`), KEY `t_account_bak_amount_idx` (`cipher_amount`))" />
+ <output sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', cipher_password VARCHAR(255) NOT NULL DEFAULT '', assisted_query_password VARCHAR(255) NOT NULL DEFAULT '', fuzzy_query_password VARCHAR(255) NOT NULL DEFAULT '', plain_password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`), KEY `t_account_bak_amount_idx` (`cipher_amount`))" />
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/delete/delete.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/delete/delete.xml
index 0cf329a3956..1c2cd8a0e70 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/delete/delete.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/delete/delete.xml
@@ -18,22 +18,22 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="delete_for_parameters" db-types="MySQL">
- <input sql="DELETE FROM t_account WHERE account_id = ? AND password = ? AND amount = ? AND status = ?" parameters="1, aaa, 1000, OK" />
- <output sql="DELETE FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND cipher_amount = ? AND status = ?" parameters="1, assisted_query_aaa, encrypt_1000, OK" />
+ <input sql="DELETE FROM t_account WHERE account_id = ? AND password = ? AND password like ? AND amount = ? AND status = ?" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="DELETE FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND fuzzy_query_password like ? AND cipher_amount = ? AND status = ?" parameters="1, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="delete_for_literals" db-types="MySQL">
- <input sql="DELETE FROM t_account WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="DELETE FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <input sql="DELETE FROM t_account WHERE account_id = 1 AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="DELETE FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND fuzzy_query_password like 'fuzzy_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="delete_plain_for_parameters" db-types="MySQL">
- <input sql="DELETE FROM t_account_bak WHERE account_id = ? AND password = ? AND amount = ? AND status = ?" parameters="1, aaa, 1000, OK" />
- <output sql="DELETE FROM t_account_bak WHERE account_id = ? AND assisted_query_password = ? AND cipher_amount = ? AND status = ?" parameters="1, assisted_query_aaa, encrypt_1000, OK" />
+ <input sql="DELETE FROM t_account_bak WHERE account_id = ? AND password = ? AND password like ? AND amount = ? AND status = ?" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="DELETE FROM t_account_bak WHERE account_id = ? AND assisted_query_password = ? AND fuzzy_query_password like ? AND cipher_amount = ? AND status = ?" parameters="1, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="delete_plain_for_literals" db-types="MySQL">
- <input sql="DELETE FROM t_account_bak WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="DELETE FROM t_account_bak WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <input sql="DELETE FROM t_account_bak WHERE account_id = 1 AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="DELETE FROM t_account_bak WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND fuzzy_query_password like 'fuzzy_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-column.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-column.xml
index 3bf1ccbaa0d..92f0b27beb8 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-column.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-column.xml
@@ -19,107 +19,107 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="insert_values_with_columns_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?), (2, '222X', 'bbb', 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', 4000, 'OK')" parameters="1, 111X, aaa, 1000, OK, 3, 333X, ccc, 3000, OK" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'encrypt_4000', 'OK')" parameters="1, encrypt_111X, assisted_query_111X, e [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'fuzzy [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_for_parameters_with_plain_column" db-types="PostgreSQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?)" parameters="1, 111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" parameters="1, encrypt_111X, assisted_query_111X, 111X, encrypt_aaa, assisted_query_aaa, aaa, encrypt_1000, 1000, OK" />
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_query_111X, 111X, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, aaa, encrypt_1000, 1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (1, '111X', 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, '333X', 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'encrypt_aaa', 'assisted_query_aaa', 'encrypt_1000', 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000', 'OK'), (3, 'encrypt_333X', 'assisted_query_333X', 'encrypt_ccc', 'assisted_query_ccc', 'encrypt_3000', ' [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'encrypt_1000', 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_ [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_and_configuration_for_different_sequence_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account(password, certificate_number, account_id, amount, status) VALUES (?, ?, ?, ?, ?), ('bbb', '222X', 2, 2000, 'OK'), (?, ?, ?, ?, ?), ('ddd', '444X', 4, 4000, 'OK')" parameters="aaa, 111X, 1, 1000, OK, ccc, 333X, 3, 3000, OK" />
- <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, cipher_certificate_number, assisted_query_certificate_number, account_id, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?), ('encrypt_bbb', 'assisted_query_bbb', 'encrypt_222X', 'assisted_query_222X', 2, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?), ('encrypt_ddd', 'assisted_query_ddd', 'encrypt_444X', 'assisted_query_444X', 4, 'encrypt_4000', 'OK')" parameters="encrypt_aaa, assisted_query_aaa, encryp [...]
+ <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, fuzzy_query_password, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, account_id, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?), ('encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 2, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?), ('encrypt_ddd', 'assisted_query_ddd', 'fuzzy_quer [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_and_configuration_for_different_sequence_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account(password, certificate_number, account_id, amount, status) VALUES ('aaa', '111X', 1, 1000, 'OK'), ('bbb', '222X', 2, 2000, 'OK'), ('ccc', '333X', 3, 3000, 'OK'), ('ddd', '444X', 4, 4000, 'OK')" />
- <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, cipher_certificate_number, assisted_query_certificate_number, account_id, cipher_amount, status) VALUES ('encrypt_aaa', 'assisted_query_aaa', 'encrypt_111X', 'assisted_query_111X', 1, 'encrypt_1000', 'OK'), ('encrypt_bbb', 'assisted_query_bbb', 'encrypt_222X', 'assisted_query_222X', 2, 'encrypt_2000', 'OK'), ('encrypt_ccc', 'assisted_query_ccc', 'encrypt_333X', 'assisted_query_333X', 3, 'encrypt_3000', ' [...]
+ <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, fuzzy_query_password, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, account_id, cipher_amount, status) VALUES ('encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', 1, 'encrypt_1000', 'OK'), ('encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_222X', 'assisted_query_222X', 'fuzzy_quer [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_with_plain_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?), (2, '222X', 'bbb', 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', 4000, 'OK')" parameters="1, 111X, aaa, 1000, OK, 3, 333X, ccc, 3000, OK" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', '444X', 'enc [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', 2 [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_with_plain_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, '111X', 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, '333X', 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'O [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assis [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_without_columns_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account VALUES (?, ?, ?, ?), (2, '222X', 'bbb', 2000), (?, ?, ?, ?), (4, '444X', 'ddd', 4000)" parameters="1, 111X, aaa, 1000, 3, 333X, ccc, 3000" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000'), (?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'encrypt_4000')" parameters="1, encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000'), (?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'fuzzy_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'fuzzy_query_ddd', 'enc [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_without_columns_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account VALUES (1, '111X', 'aaa', 1000), (2, '222X', 'bbb', 2000), (3, '333X', 'ccc', 3000), (4, '444X', 'ddd', 4000)" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'encrypt_aaa', 'assisted_query_aaa', 'encrypt_1000'), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000'), (3, 'encrypt_333X', 'assisted_query_333X', 'encrypt_ccc', 'assisted_query_ccc', 'encrypt_3000'), (4, 'encrypt_444X', [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'encrypt_1000'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000'), (3, 'encrypt_333X', 'assisted_query_333 [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_without_columns_with_plain_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account_bak VALUES (?, ?, ?, ?), (2, '222X', 'bbb', 2000), (?, ?, ?, ?), (4, '444X', 'ddd', 4000)" parameters="1, 111X, aaa, 1000, 3, 333X, ccc, 3000" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000), (?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', '444X', 'encrypt_ddd', 'assisted [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', 2000), (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'ass [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_without_columns_with_plain_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account_bak VALUES (1, '111X', 'aaa', 1000), (2, '222X', 'bbb', 2000), (3, '333X', 'ccc', 3000), (4, '444X', 'ddd', 4000)" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000), (3, 'encrypt_33 [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assiste [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount) VALUES (?, '111X', ?, ?), (2, '222X', 'bbb', 2000), (?, '333X', ?, ?), (4, '444X', 'ddd', 4000)" parameters="1, aaa, 1000, 3, ccc, 3000" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (?, 'encrypt_111X', 'assisted_query_111X', ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000'), (?, 'encrypt_333X', 'assisted_query_333X', ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'encrypt_4000')" parameters= [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount) VALUES (?, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000'), (?, 'encrypt_333X', 'assisted_query_333X', 'f [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (1, ?, 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, ?, 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" parameters="111X, 333X"/>
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (1, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'encrypt_1000', 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000', 'OK'), (3, ?, ?, 'encrypt_ccc', 'assisted_query_ccc', 'encrypt_3000', 'OK'), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'a [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (1, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'encrypt_1000', 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000', 'OK'), (3, ?, ?, ?, 'e [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_and_configuration_for_different_sequence_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account(password, certificate_number, account_id, amount, status) VALUES (?, ?, ?, 1000, ?), ('bbb', '222X', 2, 2000, 'OK'), (?, ?, ?, 3000, ?), ('ddd', '444X', 4, 4000, 'OK')" parameters="aaa, 111X, 1, OK, ccc, 333X, 3, OK" />
- <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, cipher_certificate_number, assisted_query_certificate_number, account_id, cipher_amount, status) VALUES (?, ?, ?, ?, ?, 'encrypt_1000', ?), ('encrypt_bbb', 'assisted_query_bbb', 'encrypt_222X', 'assisted_query_222X', 2, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, 'encrypt_3000', ?), ('encrypt_ddd', 'assisted_query_ddd', 'encrypt_444X', 'assisted_query_444X', 4, 'encrypt_4000', 'OK')" parameters="encrypt_aaa, [...]
+ <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, fuzzy_query_password, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, account_id, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, 'encrypt_1000', ?), ('encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 2, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?, 'encrypt_3000', ?), ('encrypt_ddd', 'assist [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_and_configuration_for_different_sequence_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account(password, certificate_number, account_id, amount, status) VALUES ('aaa', ?, 1, 1000, 'OK'), ('bbb', '222X', 2, 2000, 'OK'), ('ccc', ?, 3, 3000, 'OK'), ('ddd', '444X', 4, 4000, 'OK')" parameters="111X, 333X"/>
- <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, cipher_certificate_number, assisted_query_certificate_number, account_id, cipher_amount, status) VALUES ('encrypt_aaa', 'assisted_query_aaa', ?, ?, 1, 'encrypt_1000', 'OK'), ('encrypt_bbb', 'assisted_query_bbb', 'encrypt_222X', 'assisted_query_222X', 2, 'encrypt_2000', 'OK'), ('encrypt_ccc', 'assisted_query_ccc', ?, ?, 3, 'encrypt_3000', 'OK'), ('encrypt_ddd', 'assisted_query_ddd', 'encrypt_444X', 'assis [...]
+ <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, fuzzy_query_password, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, account_id, cipher_amount, status) VALUES ('encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', ?, ?, ?, 1, 'encrypt_1000', 'OK'), ('encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 2, 'encrypt_2000', 'OK'), ('encrypt_ccc', [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_with_plain_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (?, ?, ?, ?, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" parameters="1, 111X, aaa, 1000, 3, 333X, ccc, 3000" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?, 'OK'), (4, 'encrypt_444X', 'assisted_query_444X', '444X' [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000' [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_with_plain_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, ?, 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, ?, 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" parameters="111X, 333X"/>
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (3, ?, ?, ?, 'encrypt_ccc', 'assi [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_b [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_without_columns_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account VALUES (?, '111X', ?, ?), (2, '222X', 'bbb', 2000), (?, '333X', ?, ?), (4, '444X', 'ddd', 4000)" parameters="1, aaa, 1000, 3, ccc, 3000" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (?, 'encrypt_111X', 'assisted_query_111X', ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000'), (?, 'encrypt_333X', 'assisted_query_333X', ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'encrypt_4000')" parameters= [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (?, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000'), (?, 'encrypt_333X', 'assisted_query_333X', 'fuzzy_query_333X', ?, ?, ?, ?), (4, 'encrypt_444X', 'as [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_without_columns_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account VALUES (1, '111X', ?, 1000), (2, '222X', 'bbb', 2000), (3, '333X', ?, 3000), (4, '444X', 'ddd', 4000)" parameters="aaa, ccc"/>
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', ?, ?, 'encrypt_1000'), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000'), (3, 'encrypt_333X', 'assisted_query_333X', ?, ?, 'encrypt_3000'), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'e [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', ?, ?, ?, 'encrypt_1000'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000'), (3, 'encrypt_333X', 'assisted_query_333X', 'fuzzy_query_333X', ?, ?, ?, 'encrypt_3000' [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_without_columns_with_plain_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account_bak VALUES (?, ?, 'aaa', ?), (2, '222X', 'bbb', 2000), (?, ?, 'ccc', ?), (4, '444X', 'ddd', 4000)" parameters="1, 111X, 1000, 3, 333X, 3000" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000), (?, ?, ?, ?, 'encrypt_ccc', 'assisted_query_ccc', 'ccc', ?, ?), (4, ' [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (?, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', 2000), (?, ?, ? [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_without_columns_with_plain_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account_bak VALUES (1, ?, 'aaa', 1000), (2, '222X', 'bbb', 2000), (3, ?, 'ccc', 3000), (4, '444X', 'ddd', 4000)" parameters="111X, 333X"/>
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (1, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000), (3, ?, ?, ?, 'encrypt_ccc', 'assisted_query_ccc', 'cc [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (1, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_schema_based_algorithm_for_plain" db-types="MySQL">
@@ -134,6 +134,6 @@
<rewrite-assertion id="insert_values_with_null_encrypt_column_for_parameters" db-types="MySQL,PostgreSQL,openGauss">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?), (2, '222X', NULL, 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', NULL, 'OK')" parameters="1, NULL, aaa, 1000, OK, 3, 333X, NULL, 3000, OK" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', NULL, NULL, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', NULL, 'OK')" parameters="1, NULL, NULL, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK, 3, encry [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', NULL, NULL, NULL, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'fuzzy_query_444X', 'encrypt_ddd', 'assisted [...]
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-on-duplicate.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-on-duplicate.xml
index c67677f6869..5a6bbb31c18 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-on-duplicate.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-on-duplicate.xml
@@ -19,36 +19,36 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="insert_values_on_duplicated_update_values" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE certificate_number = VALUES(certificate_number)" parameters="1, 111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE cipher_certificate_number = VALUES(cipher_certificate_number), assisted_query_certificate_number = VALUES(assisted_query_certificate_number)" parameters="1, encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK" />
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE cipher_certificate_number = VALUES(cipher_certificate_number), assisted_query_certificate_number = VALUES(assisted_query_certificate_number), fuzzy_query_certificate_number = VALUES(fuzzy_query_cer [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_on_duplicated_update_values_wrong_match" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE status = VALUES(status)" parameters="1, 111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE status = VALUES(status)" parameters="1, encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK" />
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE status = VALUES(status)" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_query_111X, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_on_duplicate_key_update_with_columns_with_plain_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?), (2, '222X', 'bbb', 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = ?" parameters="1, 111X, aaa, 1000, OK, 3, 333X, ccc, 3000, OK, ccc_update" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', '444X', 'enc [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', 2 [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_on_duplicate_key_update_with_columns_with_plain_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, '111X', 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, '333X', 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = 'ccc_update'" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'O [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assis [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_on_duplicate_key_update_with_insert_value_literals_and_on_duplicate_parameterized" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, '111X', 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, '333X', 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = ?" parameters="ccc_update" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'O [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assis [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_on_duplicate_key_update_with_columns_with_plain_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (?, ?, 'aaa', ?, ?), (2, '222X', ?, 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = ?" parameters="1, 111X, 1000, OK, bbb, 3, 333X, ccc, 3000, OK, ccc_update" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', ?, ?, ?, 'encrypt_2000', 2000, 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', '444X', 'enc [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', ?, ?, ?, ?, 'encrypt_2000', 2 [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_on_duplicate_key_update_with_insert_value_literals_and_on_duplicate_parameterized" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, ?, 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, ?, 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = ?" parameters="111X, 333X, ccc_update" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (3, ?, ?, ?, 'encrypt_ccc', 'assi [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_b [...]
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-set.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-set.xml
index 92f121f6834..4a92d05b97f 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-set.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/insert/insert-set.xml
@@ -19,41 +19,41 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="insert_set_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account SET account_id = ?, certificate_number = ?, password = ?, amount = ?, status = ?" parameters="1, 111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, cipher_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK" />
+ <output sql="INSERT INTO t_account SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, fuzzy_query_password = ?, cipher_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_query_111X, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="insert_set_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK'" />
- <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK'" />
+ <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="insert_set_with_plain_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account_bak SET account_id = ?, certificate_number = ?, password = ?, amount = ?, status = ?" parameters="1, 111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account_bak SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, plain_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, plain_password = ?, cipher_amount = ?, plain_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, 111X, encrypt_aaa, assisted_query_aaa, aaa, encrypt_1000, 1000, OK" />
+ <output sql="INSERT INTO t_account_bak SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, plain_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, fuzzy_query_password = ?, plain_password = ?, cipher_amount = ?, plain_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_query_111X, 111X, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, aaa, encrypt_1000, 1 [...]
</rewrite-assertion>
<rewrite-assertion id="insert_set_with_plain_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account_bak SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK'" />
- <output sql="INSERT INTO t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK'" />
+ <output sql="INSERT INTO t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_set_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account SET account_id = 1, certificate_number = ?, password = ?, amount = ?, status = ?" parameters="111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = ?, assisted_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, cipher_amount = ?, status = ?" parameters="encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK" />
+ <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, fuzzy_query_password = ?, cipher_amount = ?, status = ?" parameters="encrypt_111X, assisted_query_111X, fuzzy_query_111X, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_set_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account SET account_id = 1, certificate_number = ?, password = 'aaa', amount = 1000, status = 'OK'" parameters="111X"/>
- <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = ?, assisted_query_certificate_number = ?, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK'" parameters="encrypt_111X, assisted_query_111X"/>
+ <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK'" parameters="encrypt_111X, assisted_query_111X, fuzzy_query_111X"/>
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_set_with_plain_for_parameters" db-types="MySQL">
<input sql="INSERT INTO t_account_bak SET account_id = ?, certificate_number = ?, password = 'aaa', amount = ?, status = ?" parameters="1, 111X, 1000, OK" />
- <output sql="INSERT INTO t_account_bak SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, plain_certificate_number = ?, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = ?, plain_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, 111X, encrypt_1000, 1000, OK" />
+ <output sql="INSERT INTO t_account_bak SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, plain_certificate_number = ?, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = ?, plain_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_query_111X, 111X, encrypt_1000, 1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_set_with_plain_for_literals" db-types="MySQL">
<input sql="INSERT INTO t_account_bak SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = ?, status = 'OK'" parameters="1000"/>
- <output sql="INSERT INTO t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = ?, plain_amount = ?, status = 'OK'" parameters="encrypt_1000, 1000"/>
+ <output sql="INSERT INTO t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = ?, plain_amount = ?, status = 'OK'" parameters="encrypt_1000, 1000"/>
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-group-by.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-group-by.xml
index a2279f30767..9ea8e8d8ca9 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-group-by.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-group-by.xml
@@ -18,12 +18,12 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="select_with_groupby1" db-types="MySQL">
- <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND amount = ? AND status = ? group by password desc" parameters="1, aaa, 1000, OK" />
- <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND cipher_amount = ? AND status = ? group by assisted_query_password desc" parameters="1, assisted_query_aaa, encrypt_1000, OK" />
+ <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND password like ? AND amount = ? AND status = ? group by password desc" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND fuzzy_query_password like ? AND cipher_amount = ? AND status = ? group by assisted_query_password desc" parameters="1, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="select_with_groupby2" db-types="MySQL">
- <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND amount = ? AND status = ? group by amount desc" parameters="1, aaa, 1000, OK" />
- <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND cipher_amount = ? AND status = ? group by cipher_amount desc" parameters="1, assisted_query_aaa, encrypt_1000, OK" />
+ <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND password like ? AND amount = ? AND status = ? group by amount desc" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND fuzzy_query_password like ? AND cipher_amount = ? AND status = ? group by cipher_amount desc" parameters="1, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-order-by.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-order-by.xml
index afccf9631b8..63468e477c4 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-order-by.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-order-by.xml
@@ -18,7 +18,7 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="select_with_orderby2" db-types="MySQL">
- <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND amount = ? AND status = ? order by amount desc" parameters="1, aaa, 1000, OK" />
- <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND cipher_amount = ? AND status = ? order by cipher_amount desc" parameters="1, assisted_query_aaa, encrypt_1000, OK" />
+ <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND password like ? AND amount = ? AND status = ? order by amount desc" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND fuzzy_query_password like ? AND cipher_amount = ? AND status = ? order by cipher_amount desc" parameters="1, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-projection.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-projection.xml
index 6b4cc5238ed..d33916d3f0e 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-projection.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-projection.xml
@@ -33,8 +33,8 @@
</rewrite-assertion>
<rewrite-assertion id="select_for_predicate_and_right_value_should_be_matched_for_cipher" db-types="MySQL">
- <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = 1 AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND fuzzy_query_password like 'fuzzy_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="select_with_unqualified_shorthand" db-types="MySQL">
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-subquery.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-subquery.xml
index 5086d3c16f1..1c9835c70c0 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-subquery.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-subquery.xml
@@ -18,8 +18,8 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="select_not_nested_subquery_in_projection" db-types="MySQL">
- <input sql="SELECT u.certificate_number, u.password, (SELECT o.amount FROM t_account_bak o WHERE o.certificate_number=u.certificate_number) amount FROM t_account u, t_account_bak c WHERE u.certificate_number = c.certificate_number and u.password=?" parameters="1" />
- <output sql="SELECT u.cipher_certificate_number AS certificate_number, u.cipher_password AS password, (SELECT o.cipher_amount AS amount FROM t_account_bak o WHERE o.assisted_query_certificate_number=u.assisted_query_certificate_number) amount FROM t_account u, t_account_bak c WHERE u.assisted_query_certificate_number = c.assisted_query_certificate_number and u.assisted_query_password=?" parameters="assisted_query_1" />
+ <input sql="SELECT u.certificate_number, u.password, (SELECT o.amount FROM t_account_bak o WHERE o.certificate_number=u.certificate_number) amount FROM t_account u, t_account_bak c WHERE u.certificate_number = c.certificate_number and u.password=? and u.password like ?" parameters="1, 1" />
+ <output sql="SELECT u.cipher_certificate_number AS certificate_number, u.cipher_password AS password, (SELECT o.cipher_amount AS amount FROM t_account_bak o WHERE o.assisted_query_certificate_number=u.assisted_query_certificate_number) amount FROM t_account u, t_account_bak c WHERE u.assisted_query_certificate_number = c.assisted_query_certificate_number and u.assisted_query_password=? and u.fuzzy_query_password like ?" parameters="assisted_query_1, fuzzy_query_1" />
</rewrite-assertion>
<rewrite-assertion id="select_not_nested_subquery_in_table_segment" db-types="MySQL">
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-where.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-where.xml
index 7966052b161..627609c4ca6 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-where.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/select/select-where.xml
@@ -18,28 +18,28 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="select_for_parameters" db-types="MySQL">
- <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND amount = ? AND status = ?" parameters="1, aaa, 1000, OK" />
- <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND cipher_amount = ? AND status = ?" parameters="1, assisted_query_aaa, encrypt_1000, OK" />
+ <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND password like ? AND amount = ? AND status = ?" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND fuzzy_query_password like ? AND cipher_amount = ? AND status = ?" parameters="1, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="select_with_orderby1" db-types="MySQL">
- <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND amount = ? AND status = ? order by password desc" parameters="1, aaa, 1000, OK" />
- <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND cipher_amount = ? AND status = ? order by assisted_query_password desc" parameters="1, assisted_query_aaa, encrypt_1000, OK" />
+ <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = ? AND password = ? AND password like ? AND amount = ? AND status = ? order by password desc" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = ? AND assisted_query_password = ? AND fuzzy_query_password like ? AND cipher_amount = ? AND status = ? order by assisted_query_password desc" parameters="1, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="select_for_literals" db-types="MySQL">
- <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = 1 AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND fuzzy_query_password like 'fuzzy_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="select_plain_for_parameters" db-types="MySQL">
- <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = ? AND a.password = ? AND a.amount = ? AND a.status = ?" parameters="1, aaa, 1000, OK" />
- <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = ? AND a.assisted_query_password = ? AND a.cipher_amount = ? AND a.status = ?" parameters="1, assisted_query_aaa, encrypt_1000, OK" />
+ <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = ? AND a.password = ? AND a.password like ? AND a.amount = ? AND a.status = ?" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = ? AND a.assisted_query_password = ? AND a.fuzzy_query_password like ? AND a.cipher_amount = ? AND a.status = ?" parameters="1, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="select_plain_for_literals" db-types="MySQL">
- <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = 1 AND a.password = 'aaa' AND a.amount = 1000 AND a.status = 'OK'" />
- <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = 1 AND a.assisted_query_password = 'assisted_query_aaa' AND a.cipher_amount = 'encrypt_1000' AND a.status = 'OK'" />
+ <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = 1 AND a.password = 'aaa' AND a.password like 'aaa' AND a.amount = 1000 AND a.status = 'OK'" />
+ <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = 1 AND a.assisted_query_password = 'assisted_query_aaa' AND a.fuzzy_query_password like 'fuzzy_query_aaa' AND a.cipher_amount = 'encrypt_1000' AND a.status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="select_plain_for_parameters_with_in_has_no_left_space" db-types="MySQL">
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/update/update.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/update/update.xml
index 150015a7937..fedb3324b98 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/update/update.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-cipher/dml/update/update.xml
@@ -18,13 +18,13 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-cipher.yaml">
<rewrite-assertion id="update_for_parameters" db-types="MySQL">
- <input sql="UPDATE t_account SET account_id = ?, certificate_number = ?, password = ?, amount = ?, status = ? WHERE account_id = ? AND certificate_number = ? AND password = ? AND amount = ? AND status = ?" parameters="1, 111X, aaa, 1000, OK, 1, 111X, aaa, 1000, OK" />
- <output sql="UPDATE t_account SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, cipher_amount = ?, status = ? WHERE account_id = ? AND assisted_query_certificate_number = ? AND assisted_query_password = ? AND cipher_amount = ? AND status = ?" parameters="1, encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK, 1, assisted_query_111X, assisted_query_aaa, encryp [...]
+ <input sql="UPDATE t_account SET account_id = ?, certificate_number = ?, password = ?, amount = ?, status = ? WHERE account_id = ? AND certificate_number = ? AND password = ? AND password like ? AND amount = ? AND status = ?" parameters="1, 111X, aaa, 1000, OK, 1, 111X, aaa, aaa, 1000, OK" />
+ <output sql="UPDATE t_account SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, fuzzy_query_password = ?, cipher_amount = ?, status = ? WHERE account_id = ? AND assisted_query_certificate_number = ? AND assisted_query_password = ? AND fuzzy_query_password like ? AND cipher_amount = ? AND status = ?" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_q [...]
</rewrite-assertion>
<rewrite-assertion id="update_for_literals" db-types="MySQL">
- <input sql="UPDATE t_account SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND certificate_number = '111X' AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="UPDATE t_account SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK' WHERE account_id = 1 AND assisted_query_certificate_number = 'assisted_query_111X' AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <input sql="UPDATE t_account SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND certificate_number = '111X' AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="UPDATE t_account SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK' WHERE account_id = 1 AND assisted_query_certificate_number = 'assisted_query_111X' AND assisted_query_passwor [...]
</rewrite-assertion>
<!-- TODO FIX ME!-->
@@ -34,8 +34,8 @@
<!-- </rewrite-assertion>-->
<rewrite-assertion id="update_plain_for_literals" db-types="MySQL">
- <input sql="UPDATE t_account_bak SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND certificate_number = '111X' AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="UPDATE t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK' WHERE account_id = 1 AND assisted_query_certificate_number = 'assisted_query_111X' AND assisted_query_password = 'assist [...]
+ <input sql="UPDATE t_account_bak SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND certificate_number = '111X' AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="UPDATE t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK' WHERE account_id = 1 AND [...]
</rewrite-assertion>
<!-- TODO FIX ME!-->
@@ -46,7 +46,7 @@
<rewrite-assertion id="update_plain_for_literals" db-types="MySQL">
<input sql="UPDATE t_account_bak SET account_id = 1, password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="UPDATE t_account_bak SET account_id = 1, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK' WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <output sql="UPDATE t_account_bak SET account_id = 1, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK' WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="update_blank_to_clear_plain_with_skip_encrypt_rewrite_true" db-types="MySQL">
@@ -56,12 +56,12 @@
<rewrite-assertion id="update_blank_to_clear_plain_with_skip_encrypt_rewrite_false" db-types="MySQL">
<input sql="/*SHARDINGSPHERE_HINT: SKIP_ENCRYPT_REWRITE=false*/UPDATE t_account_bak SET certificate_number = '', status = 'OK'" />
- <output sql="/*SHARDINGSPHERE_HINT: SKIP_ENCRYPT_REWRITE=false*/UPDATE t_account_bak SET cipher_certificate_number = 'encrypt_', assisted_query_certificate_number = 'assisted_query_', plain_certificate_number = '', status = 'OK'" />
+ <output sql="/*SHARDINGSPHERE_HINT: SKIP_ENCRYPT_REWRITE=false*/UPDATE t_account_bak SET cipher_certificate_number = 'encrypt_', assisted_query_certificate_number = 'assisted_query_', fuzzy_query_certificate_number = 'fuzzy_query_', plain_certificate_number = '', status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="update_blank_to_clear_plain_with_normal_skip_encrypt_rewrite_hint" db-types="MySQL">
<input sql="UPDATE t_account_bak SET certificate_number = '', status = 'OK'" />
- <output sql="UPDATE t_account_bak SET cipher_certificate_number = 'encrypt_', assisted_query_certificate_number = 'assisted_query_', plain_certificate_number = '', status = 'OK'" />
+ <output sql="UPDATE t_account_bak SET cipher_certificate_number = 'encrypt_', assisted_query_certificate_number = 'assisted_query_', fuzzy_query_certificate_number = 'fuzzy_query_', plain_certificate_number = '', status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="update_null_to_clear_plain" db-types="MySQL">
@@ -71,7 +71,7 @@
<rewrite-assertion id="update_null_to_clear_plain_with_multi" db-types="MySQL">
<input sql="UPDATE t_account_bak SET certificate_number = NULL, certificate_number = ''" />
- <output sql="UPDATE t_account_bak SET certificate_number = NULL, cipher_certificate_number = 'encrypt_', assisted_query_certificate_number = 'assisted_query_', plain_certificate_number = ''" />
+ <output sql="UPDATE t_account_bak SET certificate_number = NULL, cipher_certificate_number = 'encrypt_', assisted_query_certificate_number = 'assisted_query_', fuzzy_query_certificate_number = 'fuzzy_query_', plain_certificate_number = ''" />
</rewrite-assertion>
<rewrite-assertion id="update_null_to_clear_plain_where_is_null" db-types="MySQL">
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/ddl/create/create-table.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/ddl/create/create-table.xml
index b0b2840134b..6eddc152057 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/ddl/create/create-table.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/ddl/create/create-table.xml
@@ -19,11 +19,11 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-plain.yaml">
<rewrite-assertion id="create_table_for_plain" db-types="MySQL">
<input sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`))" />
- <output sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', cipher_password VARCHAR(255) NOT NULL DEFAULT '', assisted_query_password VARCHAR(255) NOT NULL DEFAULT '', plain_password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`))" />
+ <output sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', cipher_password VARCHAR(255) NOT NULL DEFAULT '', assisted_query_password VARCHAR(255) NOT NULL DEFAULT '', fuzzy_query_password VARCHAR(255) NOT NULL DEFAULT '', plain_password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`))" />
</rewrite-assertion>
<rewrite-assertion id="create_table_with_index_for_plain" db-types="MySQL">
<input sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`), KEY `t_account_bak_amount_idx` (`amount`))" />
- <output sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', cipher_password VARCHAR(255) NOT NULL DEFAULT '', assisted_query_password VARCHAR(255) NOT NULL DEFAULT '', plain_password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`), KEY `t_account_bak_amount_idx` (`plain_amount`))" />
+ <output sql="CREATE TABLE t_account_bak (id INT NOT NULL, name VARCHAR(100) NOT NULL DEFAULT '', cipher_password VARCHAR(255) NOT NULL DEFAULT '', assisted_query_password VARCHAR(255) NOT NULL DEFAULT '', fuzzy_query_password VARCHAR(255) NOT NULL DEFAULT '', plain_password VARCHAR(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`), KEY `t_account_bak_amount_idx` (`plain_amount`))" />
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/delete/delete.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/delete/delete.xml
index 5bdb370a705..08a7b3adc5a 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/delete/delete.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/delete/delete.xml
@@ -24,17 +24,17 @@
<!-- </rewrite-assertion>-->
<rewrite-assertion id="delete_for_literals_for_plain" db-types="MySQL">
- <input sql="DELETE FROM t_account WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="DELETE FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <input sql="DELETE FROM t_account WHERE account_id = 1 AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="DELETE FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND fuzzy_query_password like 'fuzzy_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="delete_t_account_bak__parameters_for_plain" db-types="MySQL">
- <input sql="DELETE FROM t_account_bak WHERE account_id = ? AND password = ? AND amount = ? AND status = ?" parameters="1, aaa, 1000, OK" />
- <output sql="DELETE FROM t_account_bak WHERE account_id = ? AND plain_password = ? AND plain_amount = ? AND status = ?" parameters="1, aaa, 1000, OK" />
+ <input sql="DELETE FROM t_account_bak WHERE account_id = ? AND password = ? AND password like ? AND amount = ? AND status = ?" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="DELETE FROM t_account_bak WHERE account_id = ? AND plain_password = ? AND plain_password like ? AND plain_amount = ? AND status = ?" parameters="1, aaa, aaa, 1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="delete_t_account_bak_for_literals_for_plain" db-types="MySQL">
- <input sql="DELETE FROM t_account_bak WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="DELETE FROM t_account_bak WHERE account_id = 1 AND plain_password = 'aaa' AND plain_amount = 1000 AND status = 'OK'" />
+ <input sql="DELETE FROM t_account_bak WHERE account_id = 1 AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="DELETE FROM t_account_bak WHERE account_id = 1 AND plain_password = 'aaa' AND plain_password like 'aaa' AND plain_amount = 1000 AND status = 'OK'" />
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-column.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-column.xml
index 0787e0ed036..9e24cf46c5c 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-column.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-column.xml
@@ -19,102 +19,102 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-plain.yaml">
<rewrite-assertion id="insert_values_with_columns_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?), (2, '222X', 'bbb', 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', 4000, 'OK')" parameters="1, 111X, aaa, 1000, OK, 3, 333X, ccc, 3000, OK" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'encrypt_4000', 'OK')" parameters="1, encrypt_111X, assisted_query_111X, e [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'fuzzy [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (1, '111X', 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, '333X', 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'encrypt_aaa', 'assisted_query_aaa', 'encrypt_1000', 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000', 'OK'), (3, 'encrypt_333X', 'assisted_query_333X', 'encrypt_ccc', 'assisted_query_ccc', 'encrypt_3000', ' [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'encrypt_1000', 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_ [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_and_configuration_for_different_sequence_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(password, certificate_number, account_id, amount, status) VALUES (?, ?, ?, ?, ?), ('bbb', '222X', 2, 2000, 'OK'), (?, ?, ?, ?, ?), ('ddd', '444X', 4, 4000, 'OK')" parameters="aaa, 111X, 1, 1000, OK, ccc, 333X, 3, 3000, OK" />
- <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, cipher_certificate_number, assisted_query_certificate_number, account_id, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?), ('encrypt_bbb', 'assisted_query_bbb', 'encrypt_222X', 'assisted_query_222X', 2, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?), ('encrypt_ddd', 'assisted_query_ddd', 'encrypt_444X', 'assisted_query_444X', 4, 'encrypt_4000', 'OK')" parameters="encrypt_aaa, assisted_query_aaa, encryp [...]
+ <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, fuzzy_query_password, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, account_id, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?), ('encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 2, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?), ('encrypt_ddd', 'assisted_query_ddd', 'fuzzy_quer [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_and_configuration_for_different_sequence_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(password, certificate_number, account_id, amount, status) VALUES ('aaa', '111X', 1, 1000, 'OK'), ('bbb', '222X', 2, 2000, 'OK'), ('ccc', '333X', 3, 3000, 'OK'), ('ddd', '444X', 4, 4000, 'OK')" />
- <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, cipher_certificate_number, assisted_query_certificate_number, account_id, cipher_amount, status) VALUES ('encrypt_aaa', 'assisted_query_aaa', 'encrypt_111X', 'assisted_query_111X', 1, 'encrypt_1000', 'OK'), ('encrypt_bbb', 'assisted_query_bbb', 'encrypt_222X', 'assisted_query_222X', 2, 'encrypt_2000', 'OK'), ('encrypt_ccc', 'assisted_query_ccc', 'encrypt_333X', 'assisted_query_333X', 3, 'encrypt_3000', ' [...]
+ <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, fuzzy_query_password, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, account_id, cipher_amount, status) VALUES ('encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', 1, 'encrypt_1000', 'OK'), ('encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_222X', 'assisted_query_222X', 'fuzzy_quer [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_with_plain_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?), (2, '222X', 'bbb', 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', 4000, 'OK')" parameters="1, 111X, aaa, 1000, OK, 3, 333X, ccc, 3000, OK" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', '444X', 'enc [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', 2 [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_columns_with_plain_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, '111X', 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, '333X', 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'O [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assis [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_without_columns_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account VALUES (?, ?, ?, ?), (2, '222X', 'bbb', 2000), (?, ?, ?, ?), (4, '444X', 'ddd', 4000)" parameters="1, 111X, aaa, 1000, 3, 333X, ccc, 3000" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000'), (?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'encrypt_4000')" parameters="1, encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000'), (?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'fuzzy_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'fuzzy_query_ddd', 'enc [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_without_columns_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account VALUES (1, '111X', 'aaa', 1000), (2, '222X', 'bbb', 2000), (3, '333X', 'ccc', 3000), (4, '444X', 'ddd', 4000)" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'encrypt_aaa', 'assisted_query_aaa', 'encrypt_1000'), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000'), (3, 'encrypt_333X', 'assisted_query_333X', 'encrypt_ccc', 'assisted_query_ccc', 'encrypt_3000'), (4, 'encrypt_444X', [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'encrypt_1000'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000'), (3, 'encrypt_333X', 'assisted_query_333 [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_without_columns_with_plain_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak VALUES (?, ?, ?, ?), (2, '222X', 'bbb', 2000), (?, ?, ?, ?), (4, '444X', 'ddd', 4000)" parameters="1, 111X, aaa, 1000, 3, 333X, ccc, 3000" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000), (?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', '444X', 'encrypt_ddd', 'assisted [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', 2000), (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'ass [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_without_columns_with_plain_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak VALUES (1, '111X', 'aaa', 1000), (2, '222X', 'bbb', 2000), (3, '333X', 'ccc', 3000), (4, '444X', 'ddd', 4000)" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000), (3, 'encrypt_33 [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assiste [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (?, '111X', ?, ?, ?), (2, '222X', 'bbb', 2000, 'OK'), (?, '333X', ?, ?, ?), (4, '444X', 'ddd', 4000, 'OK')" parameters="1, aaa, 1000, OK, 3, ccc, 3000, OK" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (?, 'encrypt_111X', 'assisted_query_111X', ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000', 'OK'), (?, 'encrypt_333X', 'assisted_query_333X', ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'encrypt [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (?, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000', 'OK'), (?, 'encrypt_333X', 'assiste [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (1, ?, 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, ?, 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" parameters="111X, 333X"/>
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (1, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'encrypt_1000', 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000', 'OK'), (3, ?, ?, 'encrypt_ccc', 'assisted_query_ccc', 'encrypt_3000', 'OK'), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'a [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (1, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'encrypt_1000', 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000', 'OK'), (3, ?, ?, ?, 'e [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_and_configuration_for_different_sequence_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(password, certificate_number, account_id, amount, status) VALUES (?, ?, ?, 1000, ?), ('bbb', '222X', 2, 2000, 'OK'), (?, ?, ?, 3000, ?), ('ddd', '444X', 4, 4000, 'OK')" parameters="aaa, 111X, 1, OK, ccc, 333X, 3, OK" />
- <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, cipher_certificate_number, assisted_query_certificate_number, account_id, cipher_amount, status) VALUES (?, ?, ?, ?, ?, 'encrypt_1000', ?), ('encrypt_bbb', 'assisted_query_bbb', 'encrypt_222X', 'assisted_query_222X', 2, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, 'encrypt_3000', ?), ('encrypt_ddd', 'assisted_query_ddd', 'encrypt_444X', 'assisted_query_444X', 4, 'encrypt_4000', 'OK')" parameters="encrypt_aaa, [...]
+ <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, fuzzy_query_password, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, account_id, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, 'encrypt_1000', ?), ('encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 2, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?, 'encrypt_3000', ?), ('encrypt_ddd', 'assist [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_and_configuration_for_different_sequence_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(password, certificate_number, account_id, amount, status) VALUES ('aaa', ?, 1, 1000, 'OK'), ('bbb', '222X', 2, 2000, 'OK'), ('ccc', ?, 3, 3000, 'OK'), ('ddd', '444X', 4, 4000, 'OK')" parameters="111X, 333X"/>
- <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, cipher_certificate_number, assisted_query_certificate_number, account_id, cipher_amount, status) VALUES ('encrypt_aaa', 'assisted_query_aaa', ?, ?, 1, 'encrypt_1000', 'OK'), ('encrypt_bbb', 'assisted_query_bbb', 'encrypt_222X', 'assisted_query_222X', 2, 'encrypt_2000', 'OK'), ('encrypt_ccc', 'assisted_query_ccc', ?, ?, 3, 'encrypt_3000', 'OK'), ('encrypt_ddd', 'assisted_query_ddd', 'encrypt_444X', 'assis [...]
+ <output sql="INSERT INTO t_account(cipher_password, assisted_query_password, fuzzy_query_password, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, account_id, cipher_amount, status) VALUES ('encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', ?, ?, ?, 1, 'encrypt_1000', 'OK'), ('encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 2, 'encrypt_2000', 'OK'), ('encrypt_ccc', [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_with_plain_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (?, ?, ?, ?, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" parameters="1, 111X, aaa, 1000, 3, 333X, ccc, 3000" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?, 'OK'), (4, 'encrypt_444X', 'assisted_query_444X', '444X' [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000' [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_columns_with_plain_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, ?, 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, ?, 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK')" parameters="111X, 333X"/>
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (3, ?, ?, ?, 'encrypt_ccc', 'assi [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_b [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_without_columns_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account VALUES (?, '111X', ?, ?), (2, '222X', 'bbb', 2000), (?, '333X', ?, ?), (4, '444X', 'ddd', 4000)" parameters="1, aaa, 1000, 3, ccc, 3000" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (?, 'encrypt_111X', 'assisted_query_111X', ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000'), (?, 'encrypt_333X', 'assisted_query_333X', ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'encrypt_4000')" parameters= [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (?, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000'), (?, 'encrypt_333X', 'assisted_query_333X', 'fuzzy_query_333X', ?, ?, ?, ?), (4, 'encrypt_444X', 'as [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_without_columns_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account VALUES (1, '111X', ?, 1000), (2, '222X', 'bbb', 2000), (3, '333X', ?, 3000), (4, '444X', 'ddd', 4000)" parameters="aaa, ccc"/>
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', ?, ?, 'encrypt_1000'), (2, 'encrypt_222X', 'assisted_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'encrypt_2000'), (3, 'encrypt_333X', 'assisted_query_333X', ?, ?, 'encrypt_3000'), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', 'e [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', ?, ?, ?, 'encrypt_1000'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'encrypt_2000'), (3, 'encrypt_333X', 'assisted_query_333X', 'fuzzy_query_333X', ?, ?, ?, 'encrypt_3000' [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_without_columns_with_plain_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak VALUES (?, ?, 'aaa', ?), (2, '222X', 'bbb', 2000), (?, ?, 'ccc', ?), (4, '444X', 'ddd', 4000)" parameters="1, 111X, 1000, 3, 333X, 3000" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000), (?, ?, ?, ?, 'encrypt_ccc', 'assisted_query_ccc', 'ccc', ?, ?), (4, ' [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (?, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', 2000), (?, ?, ? [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_without_columns_with_plain_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak VALUES (1, ?, 'aaa', 1000), (2, '222X', 'bbb', 2000), (3, ?, 'ccc', 3000), (4, '444X', 'ddd', 4000)" parameters="111X, 333X"/>
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (1, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000), (3, ?, ?, ?, 'encrypt_ccc', 'assisted_query_ccc', 'cc [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount) VALUES (1, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_schema_based_algorithm_for_plain_for_plain" db-types="MySQL">
@@ -129,6 +129,6 @@
<rewrite-assertion id="insert_values_with_null_encrypt_column_for_plain" db-types="MySQL,PostgreSQL,openGauss">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?), (2, '222X', NULL, 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', NULL, 'OK')" parameters="1, NULL, aaa, 1000, OK, 3, 333X, NULL, 3000, OK" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', NULL, NULL, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'encrypt_ddd', 'assisted_query_ddd', NULL, 'OK')" parameters="1, NULL, NULL, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK, 3, encry [...]
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', NULL, NULL, NULL, 'encrypt_2000', 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', 'fuzzy_query_444X', 'encrypt_ddd', 'assisted [...]
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-on-duplicate.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-on-duplicate.xml
index 699a94570a3..0d838ed22a0 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-on-duplicate.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-on-duplicate.xml
@@ -19,36 +19,36 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-plain.yaml">
<rewrite-assertion id="insert_values_on_duplicated_update_values_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE certificate_number = VALUES(certificate_number)" parameters="1, 111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE cipher_certificate_number = VALUES(cipher_certificate_number), assisted_query_certificate_number = VALUES(assisted_query_certificate_number)" parameters="1, encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK" />
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE cipher_certificate_number = VALUES(cipher_certificate_number), assisted_query_certificate_number = VALUES(assisted_query_certificate_number), fuzzy_query_certificate_number = VALUES(fuzzy_query_cer [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_on_duplicated_update_values_wrong_match_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE status = VALUES(status)" parameters="1, 111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, cipher_password, assisted_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE status = VALUES(status)" parameters="1, encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK" />
+ <output sql="INSERT INTO t_account(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, cipher_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE status = VALUES(status)" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_query_111X, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_on_duplicate_key_update_with_columns_with_plain_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (?, ?, ?, ?, ?), (2, '222X', 'bbb', 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = ?" parameters="1, 111X, aaa, 1000, OK, 3, 333X, ccc, 3000, OK, ccc_update" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', '444X', 'enc [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'fuzzy_query_bbb', 'bbb', 'encrypt_2000', 2 [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_on_duplicate_key_update_with_columns_with_plain_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, '111X', 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, '333X', 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = 'ccc_update'" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'O [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assis [...]
</rewrite-assertion>
<rewrite-assertion id="insert_values_with_on_duplicate_key_update_with_insert_value_literals_and_on_duplicate_parameterized_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, '111X', 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, '333X', 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = ?" parameters="ccc_update" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'O [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, 'encrypt_111X', 'assisted_query_111X', 'fuzzy_query_111X', '111X', 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assis [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_on_duplicate_key_update_with_columns_with_plain_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (?, ?, 'aaa', ?, ?), (2, '222X', ?, 2000, 'OK'), (?, ?, ?, ?, ?), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = ?" parameters="1, 111X, 1000, OK, bbb, 3, 333X, ccc, 3000, OK, ccc_update" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', '222X', ?, ?, ?, 'encrypt_2000', 2000, 'OK'), (?, ?, ?, ?, ?, ?, ?, ?, ?, ?), (4, 'encrypt_444X', 'assisted_query_444X', '444X', 'enc [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (?, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', ?, ?, ?), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', ?, ?, ?, ?, 'encrypt_2000', 2 [...]
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_values_with_on_duplicate_key_update_with_insert_value_literals_and_on_duplicate_parameterized_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak(account_id, certificate_number, password, amount, status) VALUES (1, ?, 'aaa', 1000, 'OK'), (2, '222X', 'bbb', 2000, 'OK'), (3, ?, 'ccc', 3000, 'OK'), (4, '444X', 'ddd', 4000, 'OK') ON DUPLICATE KEY UPDATE password = ?" parameters="111X, 333X, ccc_update" />
- <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', '222X', 'encrypt_bbb', 'assisted_query_bbb', 'bbb', 'encrypt_2000', 2000, 'OK'), (3, ?, ?, ?, 'encrypt_ccc', 'assi [...]
+ <output sql="INSERT INTO t_account_bak(account_id, cipher_certificate_number, assisted_query_certificate_number, fuzzy_query_certificate_number, plain_certificate_number, cipher_password, assisted_query_password, fuzzy_query_password, plain_password, cipher_amount, plain_amount, status) VALUES (1, ?, ?, ?, ?, 'encrypt_aaa', 'assisted_query_aaa', 'fuzzy_query_aaa', 'aaa', 'encrypt_1000', 1000, 'OK'), (2, 'encrypt_222X', 'assisted_query_222X', 'fuzzy_query_222X', '222X', 'encrypt_b [...]
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-set.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-set.xml
index b3175b5e7c0..f8723e549f5 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-set.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/insert/insert-set.xml
@@ -19,41 +19,41 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-plain.yaml">
<rewrite-assertion id="insert_set_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account SET account_id = ?, certificate_number = ?, password = ?, amount = ?, status = ?" parameters="1, 111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, cipher_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK" />
+ <output sql="INSERT INTO t_account SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, fuzzy_query_password = ?, cipher_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_query_111X, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="insert_set_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK'" />
- <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK'" />
+ <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="insert_set_with_plain_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak SET account_id = ?, certificate_number = ?, password = ?, amount = ?, status = ?" parameters="1, 111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account_bak SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, plain_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, plain_password = ?, cipher_amount = ?, plain_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, 111X, encrypt_aaa, assisted_query_aaa, aaa, encrypt_1000, 1000, OK" />
+ <output sql="INSERT INTO t_account_bak SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, plain_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, fuzzy_query_password = ?, plain_password = ?, cipher_amount = ?, plain_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_query_111X, 111X, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, aaa, encrypt_1000, 1 [...]
</rewrite-assertion>
<rewrite-assertion id="insert_set_with_plain_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK'" />
- <output sql="INSERT INTO t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK'" />
+ <output sql="INSERT INTO t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_set_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account SET account_id = 1, certificate_number = ?, password = ?, amount = ?, status = ?" parameters="111X, aaa, 1000, OK" />
- <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = ?, assisted_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, cipher_amount = ?, status = ?" parameters="encrypt_111X, assisted_query_111X, encrypt_aaa, assisted_query_aaa, encrypt_1000, OK" />
+ <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, cipher_password = ?, assisted_query_password = ?, fuzzy_query_password = ?, cipher_amount = ?, status = ?" parameters="encrypt_111X, assisted_query_111X, fuzzy_query_111X, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_set_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account SET account_id = 1, certificate_number = ?, password = 'aaa', amount = 1000, status = 'OK'" parameters="111X"/>
- <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = ?, assisted_query_certificate_number = ?, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK'" parameters="encrypt_111X, assisted_query_111X"/>
+ <output sql="INSERT INTO t_account SET account_id = 1, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK'" parameters="encrypt_111X, assisted_query_111X, fuzzy_query_111X"/>
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_set_with_plain_for_parameters_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak SET account_id = ?, certificate_number = ?, password = 'aaa', amount = ?, status = ?" parameters="1, 111X, 1000, OK" />
- <output sql="INSERT INTO t_account_bak SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, plain_certificate_number = ?, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = ?, plain_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, 111X, encrypt_1000, 1000, OK" />
+ <output sql="INSERT INTO t_account_bak SET account_id = ?, cipher_certificate_number = ?, assisted_query_certificate_number = ?, fuzzy_query_certificate_number = ?, plain_certificate_number = ?, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = ?, plain_amount = ?, status = ?" parameters="1, encrypt_111X, assisted_query_111X, fuzzy_query_111X, 111X, encrypt_1000, 1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="mixed_insert_set_with_plain_for_literals_for_plain" db-types="MySQL">
<input sql="INSERT INTO t_account_bak SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = ?, status = 'OK'" parameters="1000"/>
- <output sql="INSERT INTO t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = ?, plain_amount = ?, status = 'OK'" parameters="encrypt_1000, 1000"/>
+ <output sql="INSERT INTO t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = ?, plain_amount = ?, status = 'OK'" parameters="encrypt_1000, 1000"/>
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/select/select-projection.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/select/select-projection.xml
index cbd6f416eac..15c60adb1d6 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/select/select-projection.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/select/select-projection.xml
@@ -43,8 +43,8 @@
</rewrite-assertion>
<rewrite-assertion id="select_for_predicate_and_right_value_should_be_matched" db-types="MySQL">
- <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = 1 AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND fuzzy_query_password like 'fuzzy_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="select_with_unqualified_shorthand_for_plain" db-types="MySQL">
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/select/select-where.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/select/select-where.xml
index 17a5697b735..df3e0fc7660 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/select/select-where.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/select/select-where.xml
@@ -30,8 +30,8 @@
<!-- </rewrite-assertion>-->
<rewrite-assertion id="select_for_literals" db-types="MySQL">
- <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <input sql="SELECT account_id, password, amount AS a, status AS s FROM t_account WHERE account_id = 1 AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="SELECT account_id, cipher_password AS password, cipher_amount AS a, status AS s FROM t_account WHERE account_id = 1 AND assisted_query_password = 'assisted_query_aaa' AND fuzzy_query_password like 'fuzzy_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="select_plain_for_parameters_with_in_has_no_left_space" db-types="MySQL">
@@ -67,27 +67,27 @@
</rewrite-assertion>
<rewrite-assertion id="select_plain_with_table_level_query_with_cipher_column_for_literals" db-types="MySQL">
- <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = 1 AND a.password = 'aaa' AND a.amount = '1000' AND a.status = 'OK'" />
- <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = 1 AND a.assisted_query_password = 'assisted_query_aaa' AND a.cipher_amount = 'encrypt_1000' AND a.status = 'OK'" />
+ <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = 1 AND a.password = 'aaa' AND a.password like 'aaa' AND a.amount = '1000' AND a.status = 'OK'" />
+ <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = 1 AND a.assisted_query_password = 'assisted_query_aaa' AND a.fuzzy_query_password like 'fuzzy_query_aaa' AND a.cipher_amount = 'encrypt_1000' AND a.status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="select_plain_for_parameters" db-types="MySQL">
- <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = ? AND a.password = ? AND a.amount = ? AND a.status = ?" parameters="1, aaa, 1000, OK" />
- <output sql="SELECT a.account_id, a.plain_password AS password, a.plain_amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = ? AND a.plain_password = ? AND a.plain_amount = ? AND a.status = ?" parameters="1, aaa, 1000, OK" />
+ <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = ? AND a.password = ? AND a.password like ? AND a.amount = ? AND a.status = ?" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="SELECT a.account_id, a.plain_password AS password, a.plain_amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = ? AND a.plain_password = ? AND a.plain_password like ? AND a.plain_amount = ? AND a.status = ?" parameters="1, aaa, aaa, 1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="select_plain_for_literals" db-types="MySQL">
- <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = 1 AND a.password = 'aaa' AND a.amount = 1000 AND a.status = 'OK'" />
- <output sql="SELECT a.account_id, a.plain_password AS password, a.plain_amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = 1 AND a.plain_password = 'aaa' AND a.plain_amount = 1000 AND a.status = 'OK'" />
+ <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = 1 AND a.password = 'aaa' AND a.password like 'aaa' AND a.amount = 1000 AND a.status = 'OK'" />
+ <output sql="SELECT a.account_id, a.plain_password AS password, a.plain_amount AS a, a.status AS s FROM t_account_bak AS a WHERE a.account_id = 1 AND a.plain_password = 'aaa' AND a.plain_password like 'aaa' AND a.plain_amount = 1000 AND a.status = 'OK'" />
</rewrite-assertion>
<rewrite-assertion id="select_cipher_with_table_level_query_with_cipher_column_for_parameters" db-types="MySQL">
- <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = ? AND a.password = ? AND a.amount = ? AND a.status = ?" parameters="1, aaa, 1000, OK" />
- <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = ? AND a.assisted_query_password = ? AND a.cipher_amount = ? AND a.status = ?" parameters="1, assisted_query_aaa, encrypt_1000, OK" />
+ <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = ? AND a.password = ? AND a.password like ? AND a.amount = ? AND a.status = ?" parameters="1, aaa, aaa, 1000, OK" />
+ <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = ? AND a.assisted_query_password = ? AND a.fuzzy_query_password like ? AND a.cipher_amount = ? AND a.status = ?" parameters="1, assisted_query_aaa, fuzzy_query_aaa, encrypt_1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="select_cipher_with_table_level_query_with_cipher_column_for_literals" db-types="MySQL">
- <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = 1 AND a.password = 'aaa' AND a.amount = 1000 AND a.status = 'OK'" />
- <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = 1 AND a.assisted_query_password = 'assisted_query_aaa' AND a.cipher_amount = 'encrypt_1000' AND a.status = 'OK'" />
+ <input sql="SELECT a.account_id, a.password, a.amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = 1 AND a.password = 'aaa' AND a.password like 'aaa' AND a.amount = 1000 AND a.status = 'OK'" />
+ <output sql="SELECT a.account_id, a.cipher_password AS password, a.cipher_amount AS a, a.status AS s FROM t_account_detail AS a WHERE a.account_id = 1 AND a.assisted_query_password = 'assisted_query_aaa' AND a.fuzzy_query_password like 'fuzzy_query_aaa' AND a.cipher_amount = 'encrypt_1000' AND a.status = 'OK'" />
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/update/update.xml b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/update/update.xml
index 8c8f16a4203..93696a2c27c 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/update/update.xml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/case/query-with-plain/dml/update/update.xml
@@ -18,13 +18,13 @@
<rewrite-assertions yaml-rule="scenario/encrypt/config/query-with-plain.yaml">
<rewrite-assertion id="update_plain_for_parameters" db-types="MySQL">
- <input sql="UPDATE t_account_bak SET account_id = ?, password = ?, amount = ?, status = ? WHERE account_id = ? AND password = ? AND amount = ? AND status = ?" parameters="1, aaa, 1000, OK, 1, aaa, 1000, OK" />
- <output sql="UPDATE t_account_bak SET account_id = ?, cipher_password = ?, assisted_query_password = ?, plain_password = ?, cipher_amount = ?, plain_amount = ?, status = ? WHERE account_id = ? AND plain_password = ? AND plain_amount = ? AND status = ?" parameters="1, encrypt_aaa, assisted_query_aaa, aaa, encrypt_1000, 1000, OK, 1, aaa, 1000, OK" />
+ <input sql="UPDATE t_account_bak SET account_id = ?, password = ?, amount = ?, status = ? WHERE account_id = ? AND password = ? AND password like ? AND amount = ? AND status = ?" parameters="1, aaa, 1000, OK, 1, aaa, aaa, 1000, OK" />
+ <output sql="UPDATE t_account_bak SET account_id = ?, cipher_password = ?, assisted_query_password = ?, fuzzy_query_password = ?, plain_password = ?, cipher_amount = ?, plain_amount = ?, status = ? WHERE account_id = ? AND plain_password = ? AND plain_password like ? AND plain_amount = ? AND status = ?" parameters="1, encrypt_aaa, assisted_query_aaa, fuzzy_query_aaa, aaa, encrypt_1000, 1000, OK, 1, aaa, aaa, 1000, OK" />
</rewrite-assertion>
<rewrite-assertion id="update_plain_for_literals" db-types="MySQL">
- <input sql="UPDATE t_account_bak SET account_id = 1, password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="UPDATE t_account_bak SET account_id = 1, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK' WHERE account_id = 1 AND plain_password = 'aaa' AND plain_amount = 1000 AND status = 'OK'" />
+ <input sql="UPDATE t_account_bak SET account_id = 1, password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="UPDATE t_account_bak SET account_id = 1, cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK' WHERE account_id = 1 AND plain_password = 'aaa' AND plain_password like 'aaa' AND plain_amount = 1000 AND status = 'OK'" />
</rewrite-assertion>
<!-- TODO FIX ME-->
@@ -34,8 +34,8 @@
<!-- </rewrite-assertion>-->
<rewrite-assertion id="update_for_literals" db-types="MySQL">
- <input sql="UPDATE t_account SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND certificate_number = '111X' AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="UPDATE t_account SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK' WHERE account_id = 1 AND assisted_query_certificate_number = 'assisted_query_111X' AND assisted_query_password = 'assisted_query_aaa' AND cipher_amount = 'encrypt_1000' AND status = 'OK'" />
+ <input sql="UPDATE t_account SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND certificate_number = '111X' AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="UPDATE t_account SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', cipher_amount = 'encrypt_1000', status = 'OK' WHERE account_id = 1 AND assisted_query_certificate_number = 'assisted_query_111X' AND assisted_query_passwor [...]
</rewrite-assertion>
<!-- TODO FIX ME-->
@@ -45,7 +45,7 @@
<!-- </rewrite-assertion>-->
<rewrite-assertion id="update_plain_for_literals" db-types="MySQL">
- <input sql="UPDATE t_account_bak SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND certificate_number = '111X' AND password = 'aaa' AND amount = 1000 AND status = 'OK'" />
- <output sql="UPDATE t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK' WHERE account_id = 1 AND plain_certificate_number = '111X' AND plain_password = 'aaa' AND plain_amount = 1000 AND status [...]
+ <input sql="UPDATE t_account_bak SET account_id = 1, certificate_number = '111X', password = 'aaa', amount = 1000, status = 'OK' WHERE account_id = 1 AND certificate_number = '111X' AND password = 'aaa' AND password like 'aaa' AND amount = 1000 AND status = 'OK'" />
+ <output sql="UPDATE t_account_bak SET account_id = 1, cipher_certificate_number = 'encrypt_111X', assisted_query_certificate_number = 'assisted_query_111X', fuzzy_query_certificate_number = 'fuzzy_query_111X', plain_certificate_number = '111X', cipher_password = 'encrypt_aaa', assisted_query_password = 'assisted_query_aaa', fuzzy_query_password = 'fuzzy_query_aaa', plain_password = 'aaa', cipher_amount = 'encrypt_1000', plain_amount = 1000, status = 'OK' WHERE account_id = 1 AND [...]
</rewrite-assertion>
</rewrite-assertions>
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/config/query-with-cipher.yaml b/test/rewrite/src/test/resources/scenario/encrypt/config/query-with-cipher.yaml
index 965bbf5f675..595ea203ff4 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/config/query-with-cipher.yaml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/config/query-with-cipher.yaml
@@ -27,13 +27,17 @@ rules:
certificate_number:
cipherColumn: cipher_certificate_number
assistedQueryColumn: assisted_query_certificate_number
+ fuzzyQueryColumn: fuzzy_query_certificate_number
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
password:
cipherColumn: cipher_password
assistedQueryColumn: assisted_query_password
+ fuzzyQueryColumn: fuzzy_query_password
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
amount:
cipherColumn: cipher_amount
encryptorName: rewrite_normal_fixture
@@ -45,21 +49,27 @@ rules:
certificate_number:
cipherColumn: cipher_certificate_number
assistedQueryColumn: assisted_query_certificate_number
+ fuzzyQueryColumn: fuzzy_query_certificate_number
plainColumn: plain_certificate_number
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
password:
cipherColumn: cipher_password
assistedQueryColumn: assisted_query_password
+ fuzzyQueryColumn: fuzzy_query_password
plainColumn: plain_password
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
password_new:
cipherColumn: password_new_cipher
assistedQueryColumn: password_new_assisted
+ fuzzyQueryColumn: password_new_fuzzy
plainColumn: password_new_plain
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
amount:
cipherColumn: cipher_amount
plainColumn: plain_amount
@@ -69,15 +79,19 @@ rules:
certificate_number:
cipherColumn: cipher_certificate_number
assistedQueryColumn: assisted_query_certificate_number
+ fuzzyQueryColumn: fuzzy_query_certificate_number
plainColumn: plain_certificate_number
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
password:
cipherColumn: cipher_password
assistedQueryColumn: assisted_query_password
+ fuzzyQueryColumn: fuzzy_query_password
plainColumn: plain_password
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
amount:
cipherColumn: cipher_amount
plainColumn: plain_amount
@@ -96,3 +110,5 @@ rules:
type: REWRITE.METADATA_AWARE.FIXTURE
rewrite_assisted_query_fixture:
type: REWRITE.ASSISTED_QUERY.FIXTURE
+ rewrite_fuzzy_query_fixture:
+ type: REWRITE.FUZZY_QUERY.FIXTURE
diff --git a/test/rewrite/src/test/resources/scenario/encrypt/config/query-with-plain.yaml b/test/rewrite/src/test/resources/scenario/encrypt/config/query-with-plain.yaml
index 8275809f667..9b21749a80a 100644
--- a/test/rewrite/src/test/resources/scenario/encrypt/config/query-with-plain.yaml
+++ b/test/rewrite/src/test/resources/scenario/encrypt/config/query-with-plain.yaml
@@ -27,13 +27,17 @@ rules:
certificate_number:
cipherColumn: cipher_certificate_number
assistedQueryColumn: assisted_query_certificate_number
+ fuzzyQueryColumn: fuzzy_query_certificate_number
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
password:
cipherColumn: cipher_password
assistedQueryColumn: assisted_query_password
+ fuzzyQueryColumn: fuzzy_query_password
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
amount:
cipherColumn: cipher_amount
encryptorName: rewrite_normal_fixture
@@ -45,21 +49,27 @@ rules:
certificate_number:
cipherColumn: cipher_certificate_number
assistedQueryColumn: assisted_query_certificate_number
+ fuzzyQueryColumn: fuzzy_query_certificate_number
plainColumn: plain_certificate_number
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
password:
cipherColumn: cipher_password
assistedQueryColumn: assisted_query_password
+ fuzzyQueryColumn: fuzzy_query_password
plainColumn: plain_password
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
password_new:
cipherColumn: password_new_cipher
assistedQueryColumn: password_new_assisted
+ fuzzyQueryColumn: password_new_fuzzy
plainColumn: password_new_plain
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
amount:
cipherColumn: cipher_amount
plainColumn: plain_amount
@@ -69,15 +79,19 @@ rules:
certificate_number:
cipherColumn: cipher_certificate_number
assistedQueryColumn: assisted_query_certificate_number
+ fuzzyQueryColumn: fuzzy_query_certificate_number
plainColumn: plain_certificate_number
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
password:
cipherColumn: cipher_password
assistedQueryColumn: assisted_query_password
+ fuzzyQueryColumn: fuzzy_query_password
plainColumn: plain_password
encryptorName: rewrite_normal_fixture
assistedQueryEncryptorName: rewrite_assisted_query_fixture
+ fuzzyQueryEncryptorName: rewrite_fuzzy_query_fixture
amount:
cipherColumn: cipher_amount
plainColumn: plain_amount
@@ -96,4 +110,6 @@ rules:
type: REWRITE.METADATA_AWARE.FIXTURE
rewrite_assisted_query_fixture:
type: REWRITE.ASSISTED_QUERY.FIXTURE
+ rewrite_fuzzy_query_fixture:
+ type: REWRITE.FUZZY_QUERY.FIXTURE
queryWithCipherColumn: false