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 0db3f104a41 Refactor EncryptTokenGenerators (#26310)
0db3f104a41 is described below
commit 0db3f104a411d6148dfcd40c565796cf998234ef
Author: Liang Zhang <[email protected]>
AuthorDate: Tue Jun 13 06:11:10 2023 +0800
Refactor EncryptTokenGenerators (#26310)
* Refactor EncryptIndexColumnTokenGenerator
* Refactor EncryptInsertOnUpdateTokenGenerator
* Refactor EncryptProjectionTokenGenerator
---
.../EncryptIndexColumnTokenGenerator.java | 19 +++--
.../EncryptInsertOnUpdateTokenGenerator.java | 89 ++++++++++------------
.../generator/EncryptProjectionTokenGenerator.java | 60 +++++++--------
.../EncryptInsertOnUpdateTokenGeneratorTest.java | 14 +++-
.../EncryptProjectionTokenGeneratorTest.java | 7 +-
5 files changed, 96 insertions(+), 93 deletions(-)
diff --git
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptIndexColumnTokenGenerator.java
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptIndexColumnTokenGenerator.java
index f2048c64f6d..5edab600cf5 100644
---
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptIndexColumnTokenGenerator.java
+++
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptIndexColumnTokenGenerator.java
@@ -21,6 +21,7 @@ import com.google.common.base.Preconditions;
import lombok.Setter;
import org.apache.shardingsphere.encrypt.rewrite.aware.EncryptRuleAware;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
+import org.apache.shardingsphere.encrypt.rule.EncryptTable;
import
org.apache.shardingsphere.infra.binder.segment.select.projection.Projection;
import
org.apache.shardingsphere.infra.binder.segment.select.projection.impl.ColumnProjection;
import org.apache.shardingsphere.infra.binder.statement.SQLStatementContext;
@@ -56,21 +57,25 @@ public final class EncryptIndexColumnTokenGenerator
implements CollectionSQLToke
if (sqlStatementContext.getTablesContext().getTableNames().isEmpty()) {
return Collections.emptyList();
}
- Collection<SQLToken> result = new LinkedList<>();
String tableName =
sqlStatementContext.getTablesContext().getTableNames().iterator().next();
+ Optional<EncryptTable> encryptTable =
encryptRule.findEncryptTable(tableName);
+ if (!encryptTable.isPresent()) {
+ return Collections.emptyList();
+ }
+ Collection<SQLToken> result = new LinkedList<>();
for (ColumnSegment each : ((IndexAvailable)
sqlStatementContext).getIndexColumns()) {
- encryptRule.findStandardEncryptor(tableName,
each.getIdentifier().getValue()).flatMap(optional -> getColumnToken(tableName,
each)).ifPresent(result::add);
+ encryptRule.findStandardEncryptor(tableName,
each.getIdentifier().getValue()).flatMap(optional ->
getColumnToken(encryptTable.get(), each)).ifPresent(result::add);
}
return result;
}
- private Optional<SQLToken> getColumnToken(final String tableName, final
ColumnSegment columnSegment) {
+ private Optional<SQLToken> getColumnToken(final EncryptTable encryptTable,
final ColumnSegment columnSegment) {
String columnName = columnSegment.getIdentifier().getValue();
QuoteCharacter quoteCharacter =
columnSegment.getIdentifier().getQuoteCharacter();
int startIndex = columnSegment.getStartIndex();
int stopIndex = columnSegment.getStopIndex();
- return encryptRule.findAssistedQueryColumn(tableName,
columnName).map(optional -> getAssistedQueryColumnToken(startIndex, stopIndex,
optional, quoteCharacter))
- .orElseGet(() -> getCipherColumnToken(tableName, startIndex,
stopIndex, columnName, quoteCharacter));
+ return encryptTable.findAssistedQueryColumn(columnName).map(optional
-> getAssistedQueryColumnToken(startIndex, stopIndex, optional, quoteCharacter))
+ .orElseGet(() -> getCipherColumnToken(encryptTable,
startIndex, stopIndex, columnName, quoteCharacter));
}
private Optional<SQLToken> getAssistedQueryColumnToken(final int
startIndex, final int stopIndex, final String columnName, final QuoteCharacter
quoteCharacter) {
@@ -78,8 +83,8 @@ public final class EncryptIndexColumnTokenGenerator
implements CollectionSQLToke
return Optional.of(new SubstitutableColumnNameToken(startIndex,
stopIndex, columnProjections, quoteCharacter));
}
- private Optional<SQLToken> getCipherColumnToken(final String tableName,
final int startIndex, final int stopIndex, final String columnName, final
QuoteCharacter quoteCharacter) {
- String cipherColumn = encryptRule.getCipherColumn(tableName,
columnName);
+ private Optional<SQLToken> getCipherColumnToken(final EncryptTable
encryptTable, final int startIndex, final int stopIndex, final String
columnName, final QuoteCharacter quoteCharacter) {
+ String cipherColumn = encryptTable.getCipherColumn(columnName);
Collection<Projection> columnProjections =
getColumnProjections(cipherColumn, quoteCharacter);
return Optional.of(new SubstitutableColumnNameToken(startIndex,
stopIndex, columnProjections, quoteCharacter));
}
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 1765feb3d74..9cd630a7b85 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
@@ -27,6 +27,7 @@ import
org.apache.shardingsphere.encrypt.rewrite.token.pojo.EncryptFunctionAssig
import
org.apache.shardingsphere.encrypt.rewrite.token.pojo.EncryptLiteralAssignmentToken;
import
org.apache.shardingsphere.encrypt.rewrite.token.pojo.EncryptParameterAssignmentToken;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
+import org.apache.shardingsphere.encrypt.rule.EncryptTable;
import org.apache.shardingsphere.infra.binder.statement.SQLStatementContext;
import
org.apache.shardingsphere.infra.binder.statement.dml.InsertStatementContext;
import org.apache.shardingsphere.infra.database.type.DatabaseTypeEngine;
@@ -64,16 +65,20 @@ public final class EncryptInsertOnUpdateTokenGenerator
implements CollectionSQLT
@Override
public Collection<SQLToken> generateSQLTokens(final InsertStatementContext
insertStatementContext) {
- Collection<SQLToken> result = new LinkedList<>();
InsertStatement insertStatement =
insertStatementContext.getSqlStatement();
Preconditions.checkState(InsertStatementHandler.getOnDuplicateKeyColumnsSegment(insertStatement).isPresent());
OnDuplicateKeyColumnsSegment onDuplicateKeyColumnsSegment =
InsertStatementHandler.getOnDuplicateKeyColumnsSegment(insertStatement).get();
Collection<AssignmentSegment> onDuplicateKeyColumnsSegments =
onDuplicateKeyColumnsSegment.getColumns();
if (onDuplicateKeyColumnsSegments.isEmpty()) {
- return result;
+ return Collections.emptyList();
}
String schemaName =
insertStatementContext.getTablesContext().getSchemaName().orElseGet(() ->
DatabaseTypeEngine.getDefaultSchemaName(insertStatementContext.getDatabaseType(),
databaseName));
String tableName =
insertStatement.getTable().getTableName().getIdentifier().getValue();
+ Optional<EncryptTable> encryptTable =
encryptRule.findEncryptTable(tableName);
+ if (!encryptTable.isPresent()) {
+ return Collections.emptyList();
+ }
+ Collection<SQLToken> result = new LinkedList<>();
for (AssignmentSegment each : onDuplicateKeyColumnsSegments) {
boolean leftEncryptorPresent =
encryptRule.findStandardEncryptor(tableName,
each.getColumns().get(0).getIdentifier().getValue()).isPresent();
if (each.getValue() instanceof FunctionSegment &&
"VALUES".equalsIgnoreCase(((FunctionSegment)
each.getValue()).getFunctionName())) {
@@ -86,65 +91,65 @@ public final class EncryptInsertOnUpdateTokenGenerator
implements CollectionSQLT
if (!leftEncryptorPresent) {
continue;
}
- generateSQLToken(schemaName, tableName,
each).ifPresent(result::add);
+ generateSQLToken(schemaName, encryptTable.get(),
each).ifPresent(result::add);
}
return result;
}
- private Optional<EncryptAssignmentToken> generateSQLToken(final String
schemaName, final String tableName, final AssignmentSegment assignmentSegment) {
+ private Optional<EncryptAssignmentToken> generateSQLToken(final String
schemaName, final EncryptTable encryptTable, final AssignmentSegment
assignmentSegment) {
if (assignmentSegment.getValue() instanceof
ParameterMarkerExpressionSegment) {
- return Optional.of(generateParameterSQLToken(tableName,
assignmentSegment));
+ return Optional.of(generateParameterSQLToken(encryptTable,
assignmentSegment));
}
if (assignmentSegment.getValue() instanceof FunctionSegment &&
"VALUES".equalsIgnoreCase(((FunctionSegment)
assignmentSegment.getValue()).getFunctionName())) {
- return Optional.of(generateValuesSQLToken(tableName,
assignmentSegment, (FunctionSegment) assignmentSegment.getValue()));
+ return Optional.of(generateValuesSQLToken(encryptTable,
assignmentSegment, (FunctionSegment) assignmentSegment.getValue()));
}
if (assignmentSegment.getValue() instanceof LiteralExpressionSegment) {
- return Optional.of(generateLiteralSQLToken(schemaName, tableName,
assignmentSegment));
+ return Optional.of(generateLiteralSQLToken(schemaName,
encryptTable, assignmentSegment));
}
return Optional.empty();
}
- private EncryptAssignmentToken generateParameterSQLToken(final String
tableName, final AssignmentSegment assignmentSegment) {
+ private EncryptAssignmentToken generateParameterSQLToken(final
EncryptTable encryptTable, final AssignmentSegment assignmentSegment) {
EncryptParameterAssignmentToken result = new
EncryptParameterAssignmentToken(assignmentSegment.getColumns().get(0).getStartIndex(),
assignmentSegment.getStopIndex());
String columnName =
assignmentSegment.getColumns().get(0).getIdentifier().getValue();
- addCipherColumn(tableName, columnName, result);
- addAssistedQueryColumn(tableName, columnName, result);
- addLikeQueryColumn(tableName, columnName, result);
+ result.addColumnName(encryptTable.getCipherColumn(columnName));
+
encryptTable.findAssistedQueryColumn(columnName).ifPresent(result::addColumnName);
+
encryptTable.findLikeQueryColumn(columnName).ifPresent(result::addColumnName);
return result;
}
- private EncryptAssignmentToken generateLiteralSQLToken(final String
schemaName, final String tableName, final AssignmentSegment assignmentSegment) {
+ private EncryptAssignmentToken generateLiteralSQLToken(final String
schemaName, final EncryptTable encryptTable, final AssignmentSegment
assignmentSegment) {
EncryptLiteralAssignmentToken result = new
EncryptLiteralAssignmentToken(assignmentSegment.getColumns().get(0).getStartIndex(),
assignmentSegment.getStopIndex());
- addCipherAssignment(schemaName, tableName, assignmentSegment, result);
- addAssistedQueryAssignment(schemaName, tableName, assignmentSegment,
result);
- addLikeAssignment(schemaName, tableName, assignmentSegment, result);
+ addCipherAssignment(schemaName, encryptTable, assignmentSegment,
result);
+ addAssistedQueryAssignment(schemaName, encryptTable,
assignmentSegment, result);
+ addLikeAssignment(schemaName, encryptTable, assignmentSegment, result);
return result;
}
- private EncryptAssignmentToken generateValuesSQLToken(final String
tableName, final AssignmentSegment assignmentSegment, final FunctionSegment
functionSegment) {
+ private EncryptAssignmentToken generateValuesSQLToken(final EncryptTable
encryptTable, final AssignmentSegment assignmentSegment, final FunctionSegment
functionSegment) {
ColumnSegment columnSegment = assignmentSegment.getColumns().get(0);
String column = columnSegment.getIdentifier().getValue();
ColumnSegment valueColumnSegment = (ColumnSegment)
functionSegment.getParameters().stream().findFirst().get();
String valueColumn = valueColumnSegment.getIdentifier().getValue();
EncryptFunctionAssignmentToken result = new
EncryptFunctionAssignmentToken(columnSegment.getStartIndex(),
assignmentSegment.getStopIndex());
- boolean cipherColumnPresent =
encryptRule.findStandardEncryptor(tableName, column).isPresent();
- boolean cipherValueColumnPresent =
encryptRule.findStandardEncryptor(tableName, valueColumn).isPresent();
+ boolean cipherColumnPresent =
encryptRule.findStandardEncryptor(encryptTable.getTable(), column).isPresent();
+ boolean cipherValueColumnPresent =
encryptRule.findStandardEncryptor(encryptTable.getTable(),
valueColumn).isPresent();
if (cipherColumnPresent && cipherValueColumnPresent) {
- String cipherColumn = encryptRule.getCipherColumn(tableName,
column);
- String cipherValueColumn = encryptRule.getCipherColumn(tableName,
valueColumn);
+ String cipherColumn = encryptTable.getCipherColumn(column);
+ String cipherValueColumn =
encryptTable.getCipherColumn(valueColumn);
result.addAssignment(cipherColumn, "VALUES(" + cipherValueColumn +
")");
} else if (cipherColumnPresent != cipherValueColumnPresent) {
throw new
UnsupportedEncryptSQLException(String.format("%s=VALUES(%s)", column,
valueColumn));
}
- Optional<String> assistedQueryColumn =
encryptRule.findAssistedQueryColumn(tableName, column);
- Optional<String> valueAssistedQueryColumn =
encryptRule.findAssistedQueryColumn(tableName, valueColumn);
+ Optional<String> assistedQueryColumn =
encryptTable.findAssistedQueryColumn(column);
+ Optional<String> valueAssistedQueryColumn =
encryptTable.findAssistedQueryColumn(valueColumn);
if (assistedQueryColumn.isPresent() &&
valueAssistedQueryColumn.isPresent()) {
result.addAssignment(assistedQueryColumn.get(), "VALUES(" +
valueAssistedQueryColumn.get() + ")");
} else if (assistedQueryColumn.isPresent() !=
valueAssistedQueryColumn.isPresent()) {
throw new
UnsupportedEncryptSQLException(String.format("%s=VALUES(%s)", column,
valueColumn));
}
- Optional<String> likeQueryColumn =
encryptRule.findLikeQueryColumn(tableName, column);
- Optional<String> valueLikeQueryColumn =
encryptRule.findLikeQueryColumn(tableName, valueColumn);
+ Optional<String> likeQueryColumn =
encryptTable.findLikeQueryColumn(column);
+ Optional<String> valueLikeQueryColumn =
encryptTable.findLikeQueryColumn(valueColumn);
if (likeQueryColumn.isPresent() && valueLikeQueryColumn.isPresent()) {
result.addAssignment(likeQueryColumn.get(), "VALUES(" +
valueLikeQueryColumn.get() + ")");
} else if (likeQueryColumn.isPresent() !=
valueLikeQueryColumn.isPresent()) {
@@ -156,41 +161,27 @@ public final class EncryptInsertOnUpdateTokenGenerator
implements CollectionSQLT
return result;
}
- private void addCipherColumn(final String tableName, final String
columnName, final EncryptParameterAssignmentToken token) {
- token.addColumnName(encryptRule.getCipherColumn(tableName,
columnName));
- }
-
- private void addAssistedQueryColumn(final String tableName, final String
columnName, final EncryptParameterAssignmentToken token) {
- encryptRule.findAssistedQueryColumn(tableName,
columnName).ifPresent(token::addColumnName);
- }
-
- private void addLikeQueryColumn(final String tableName, final String
columnName, final EncryptParameterAssignmentToken token) {
- encryptRule.findLikeQueryColumn(tableName,
columnName).ifPresent(token::addColumnName);
- }
-
- private void addCipherAssignment(final String schemaName, final String
tableName, final AssignmentSegment assignmentSegment, final
EncryptLiteralAssignmentToken token) {
+ private void addCipherAssignment(final String schemaName, final
EncryptTable encryptTable, final AssignmentSegment assignmentSegment, final
EncryptLiteralAssignmentToken token) {
Object originalValue = ((LiteralExpressionSegment)
assignmentSegment.getValue()).getLiterals();
- Object cipherValue = encryptRule.encrypt(databaseName, schemaName,
tableName, assignmentSegment.getColumns().get(0).getIdentifier().getValue(),
+ Object cipherValue = encryptRule.encrypt(databaseName, schemaName,
encryptTable.getTable(),
assignmentSegment.getColumns().get(0).getIdentifier().getValue(),
Collections.singletonList(originalValue)).iterator().next();
- token.addAssignment(encryptRule.getCipherColumn(tableName,
assignmentSegment.getColumns().get(0).getIdentifier().getValue()), cipherValue);
+
token.addAssignment(encryptTable.getCipherColumn(assignmentSegment.getColumns().get(0).getIdentifier().getValue()),
cipherValue);
}
- private void addAssistedQueryAssignment(final String schemaName, final
String tableName, final AssignmentSegment assignmentSegment, final
EncryptLiteralAssignmentToken token) {
- encryptRule.findAssistedQueryColumn(tableName,
assignmentSegment.getColumns().get(0).getIdentifier().getValue()).ifPresent(optional
-> {
+ private void addAssistedQueryAssignment(final String schemaName, final
EncryptTable encryptTable, final AssignmentSegment assignmentSegment, final
EncryptLiteralAssignmentToken token) {
+
encryptTable.findAssistedQueryColumn(assignmentSegment.getColumns().get(0).getIdentifier().getValue()).ifPresent(optional
-> {
Object originalValue = ((LiteralExpressionSegment)
assignmentSegment.getValue()).getLiterals();
- Object assistedQueryValue = encryptRule
- .getEncryptAssistedQueryValues(databaseName, schemaName,
tableName, assignmentSegment.getColumns().get(0).getIdentifier().getValue(),
Collections.singletonList(originalValue))
- .iterator().next();
+ Object assistedQueryValue =
encryptRule.getEncryptAssistedQueryValues(
+ databaseName, schemaName, encryptTable.getTable(),
assignmentSegment.getColumns().get(0).getIdentifier().getValue(),
Collections.singletonList(originalValue)).iterator().next();
token.addAssignment(optional, assistedQueryValue);
});
}
- private void addLikeAssignment(final String schemaName, final String
tableName, final AssignmentSegment assignmentSegment, final
EncryptLiteralAssignmentToken token) {
- encryptRule.findLikeQueryColumn(tableName,
assignmentSegment.getColumns().get(0).getIdentifier().getValue()).ifPresent(optional
-> {
+ private void addLikeAssignment(final String schemaName, final EncryptTable
encryptTable, final AssignmentSegment assignmentSegment, final
EncryptLiteralAssignmentToken token) {
+
encryptTable.findLikeQueryColumn(assignmentSegment.getColumns().get(0).getIdentifier().getValue()).ifPresent(optional
-> {
Object originalValue = ((LiteralExpressionSegment)
assignmentSegment.getValue()).getLiterals();
- Object likeValue = encryptRule
- .getEncryptLikeQueryValues(databaseName, schemaName,
tableName, assignmentSegment.getColumns().get(0).getIdentifier().getValue(),
Collections.singletonList(originalValue))
- .iterator().next();
+ Object likeValue = encryptRule.getEncryptLikeQueryValues(
+ databaseName, schemaName, encryptTable.getTable(),
assignmentSegment.getColumns().get(0).getIdentifier().getValue(),
Collections.singletonList(originalValue)).iterator().next();
token.addAssignment(optional, likeValue);
});
}
diff --git
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptProjectionTokenGenerator.java
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptProjectionTokenGenerator.java
index a5e55d3e2cd..5433c1cf0d5 100644
---
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptProjectionTokenGenerator.java
+++
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptProjectionTokenGenerator.java
@@ -21,6 +21,7 @@ import com.google.common.base.Preconditions;
import lombok.Setter;
import org.apache.shardingsphere.encrypt.rewrite.aware.EncryptRuleAware;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
+import org.apache.shardingsphere.encrypt.rule.EncryptTable;
import
org.apache.shardingsphere.infra.binder.segment.select.projection.Projection;
import
org.apache.shardingsphere.infra.binder.segment.select.projection.ProjectionsContext;
import
org.apache.shardingsphere.infra.binder.segment.select.projection.impl.ColumnProjection;
@@ -80,7 +81,7 @@ public final class EncryptProjectionTokenGenerator implements
CollectionSQLToken
return result;
}
- private void addGenerateSQLTokens(final Collection<SQLToken> result, final
SelectStatementContext selectStatementContext) {
+ private void addGenerateSQLTokens(final Collection<SQLToken> sqlTokens,
final SelectStatementContext selectStatementContext) {
Map<String, String> columnTableNames =
getColumnTableNames(selectStatementContext);
for (ProjectionSegment each :
selectStatementContext.getSqlStatement().getProjections().getProjections()) {
SubqueryType subqueryType =
selectStatementContext.getSubqueryType();
@@ -88,27 +89,30 @@ public final class EncryptProjectionTokenGenerator
implements CollectionSQLToken
ColumnProjectionSegment columnSegment =
(ColumnProjectionSegment) each;
ColumnProjection columnProjection =
buildColumnProjection(columnSegment);
String tableName =
columnTableNames.get(columnProjection.getExpression());
- if (null != tableName &&
encryptRule.findEncryptTable(tableName).flatMap(optional ->
optional.findEncryptColumn(columnProjection.getName())).isPresent()) {
- result.add(generateSQLToken(tableName, columnSegment,
columnProjection, subqueryType));
+ if (null == tableName) {
+ continue;
+ }
+ Optional<EncryptTable> encryptTable =
encryptRule.findEncryptTable(tableName);
+ if (!encryptTable.isPresent()) {
+ continue;
+ }
+ if
(encryptTable.get().findEncryptColumn(columnProjection.getName()).isPresent()) {
+ sqlTokens.add(generateSQLToken(encryptTable.get(),
columnSegment, columnProjection, subqueryType));
}
}
if (each instanceof ShorthandProjectionSegment) {
ShorthandProjectionSegment shorthandSegment =
(ShorthandProjectionSegment) each;
Collection<Projection> actualColumns =
getShorthandProjection(shorthandSegment,
selectStatementContext.getProjectionsContext()).getActualColumns();
if (!actualColumns.isEmpty()) {
- result.add(generateSQLToken(shorthandSegment,
actualColumns, selectStatementContext, subqueryType, columnTableNames));
+ sqlTokens.add(generateSQLToken(shorthandSegment,
actualColumns, selectStatementContext, subqueryType, columnTableNames));
}
}
}
}
- private boolean isEncryptColumn(final String tableName, final String
columnName) {
- return null != tableName &&
encryptRule.findEncryptTable(tableName).flatMap(optional ->
optional.findEncryptColumn(columnName)).isPresent();
- }
-
- private SubstitutableColumnNameToken generateSQLToken(final String
tableName, final ColumnProjectionSegment columnSegment,
+ private SubstitutableColumnNameToken generateSQLToken(final EncryptTable
encryptTable, final ColumnProjectionSegment columnSegment,
final
ColumnProjection columnProjection, final SubqueryType subqueryType) {
- Collection<Projection> projections = generateProjections(tableName,
columnProjection, subqueryType, false, null);
+ Collection<Projection> projections = generateProjections(encryptTable,
columnProjection, subqueryType, false, null);
int startIndex = columnSegment.getColumn().getOwner().isPresent() ?
columnSegment.getColumn().getOwner().get().getStopIndex() + 2 :
columnSegment.getColumn().getStartIndex();
int stopIndex = columnSegment.getStopIndex();
return new SubstitutableColumnNameToken(startIndex, stopIndex,
projections);
@@ -122,7 +126,7 @@ public final class EncryptProjectionTokenGenerator
implements CollectionSQLToken
if (null == tableName ||
!encryptRule.findEncryptTable(tableName).flatMap(optional ->
optional.findEncryptColumn(each.getColumnLabel())).isPresent()) {
projections.add(each.getAlias().map(optional -> (Projection)
new ColumnProjection(null, optional, null)).orElse(each));
} else if (each instanceof ColumnProjection) {
- projections.addAll(generateProjections(tableName,
(ColumnProjection) each, subqueryType, true, segment));
+ encryptRule.findEncryptTable(tableName).ifPresent(optional ->
projections.addAll(generateProjections(optional, (ColumnProjection) each,
subqueryType, true, segment)));
}
}
int startIndex = segment.getOwner().isPresent() ?
segment.getOwner().get().getStartIndex() : segment.getStartIndex();
@@ -150,17 +154,17 @@ public final class EncryptProjectionTokenGenerator
implements CollectionSQLToken
return
selectStatementContext.getTablesContext().findTableNamesByColumnProjection(columns,
schema);
}
- private Collection<Projection> generateProjections(final String tableName,
final ColumnProjection column, final SubqueryType subqueryType, final boolean
shorthand,
+ private Collection<Projection> generateProjections(final EncryptTable
encryptTable, final ColumnProjection column, final SubqueryType subqueryType,
final boolean shorthand,
final
ShorthandProjectionSegment segment) {
Collection<Projection> result = new LinkedList<>();
if (SubqueryType.PREDICATE_SUBQUERY == subqueryType) {
-
result.add(distinctOwner(generatePredicateSubqueryProjection(tableName,
column), shorthand));
+
result.add(distinctOwner(generatePredicateSubqueryProjection(encryptTable,
column), shorthand));
} else if (SubqueryType.TABLE_SUBQUERY == subqueryType) {
- result.addAll(generateTableSubqueryProjections(tableName, column,
shorthand));
+ result.addAll(generateTableSubqueryProjections(encryptTable,
column, shorthand));
} else if (SubqueryType.EXISTS_SUBQUERY == subqueryType) {
- result.addAll(generateExistsSubqueryProjections(tableName, column,
shorthand));
+ result.addAll(generateExistsSubqueryProjections(encryptTable,
column, shorthand));
} else {
- result.add(distinctOwner(generateCommonProjection(tableName,
column, segment), shorthand));
+ result.add(distinctOwner(generateCommonProjection(encryptTable,
column, segment), shorthand));
}
return result;
}
@@ -172,43 +176,39 @@ public final class EncryptProjectionTokenGenerator
implements CollectionSQLToken
return new ColumnProjection(null, column.getNameIdentifier(),
column.getAlias().isPresent() ? column.getAliasIdentifier() : null);
}
- private ColumnProjection generatePredicateSubqueryProjection(final String
tableName, final ColumnProjection column) {
- Optional<String> assistedQueryColumn =
encryptRule.findAssistedQueryColumn(tableName, column.getName());
+ private ColumnProjection generatePredicateSubqueryProjection(final
EncryptTable encryptTable, final ColumnProjection column) {
+ Optional<String> assistedQueryColumn =
encryptTable.findAssistedQueryColumn(column.getName());
if (assistedQueryColumn.isPresent()) {
return new ColumnProjection(column.getOwnerIdentifier(), new
IdentifierValue(assistedQueryColumn.get(),
column.getNameIdentifier().getQuoteCharacter()), null);
}
- String cipherColumn = encryptRule.getCipherColumn(tableName,
column.getName());
+ String cipherColumn = encryptTable.getCipherColumn(column.getName());
return new ColumnProjection(column.getOwnerIdentifier(), new
IdentifierValue(cipherColumn, column.getNameIdentifier().getQuoteCharacter()),
null);
}
- private Collection<ColumnProjection>
generateTableSubqueryProjections(final String tableName, final ColumnProjection
column, final boolean shorthand) {
+ private Collection<ColumnProjection>
generateTableSubqueryProjections(final EncryptTable encryptTable, final
ColumnProjection column, final boolean shorthand) {
Collection<ColumnProjection> result = new LinkedList<>();
- result.add(distinctOwner(new
ColumnProjection(column.getOwnerIdentifier(), new
IdentifierValue(encryptRule.getCipherColumn(tableName, column.getName()),
+ result.add(distinctOwner(new
ColumnProjection(column.getOwnerIdentifier(), new
IdentifierValue(encryptTable.getCipherColumn(column.getName()),
column.getNameIdentifier().getQuoteCharacter()), null),
shorthand));
- Optional<String> assistedQueryColumn =
encryptRule.findAssistedQueryColumn(tableName, column.getName());
+ Optional<String> assistedQueryColumn =
encryptTable.findAssistedQueryColumn(column.getName());
assistedQueryColumn.ifPresent(optional -> result.add(new
ColumnProjection(column.getOwnerIdentifier(), new IdentifierValue(optional,
column.getNameIdentifier().getQuoteCharacter()), null)));
return result;
}
- private Collection<ColumnProjection>
generateExistsSubqueryProjections(final String tableName, final
ColumnProjection column, final boolean shorthand) {
+ private Collection<ColumnProjection>
generateExistsSubqueryProjections(final EncryptTable encryptTable, final
ColumnProjection column, final boolean shorthand) {
Collection<ColumnProjection> result = new LinkedList<>();
- result.add(distinctOwner(new
ColumnProjection(column.getOwnerIdentifier(), new
IdentifierValue(encryptRule.getCipherColumn(tableName, column.getName()),
+ result.add(distinctOwner(new
ColumnProjection(column.getOwnerIdentifier(), new
IdentifierValue(encryptTable.getCipherColumn(column.getName()),
column.getNameIdentifier().getQuoteCharacter()), null),
shorthand));
return result;
}
- private ColumnProjection generateCommonProjection(final String tableName,
final ColumnProjection column, final ShorthandProjectionSegment segment) {
- String encryptColumnName = getEncryptColumnName(tableName,
column.getName());
+ private ColumnProjection generateCommonProjection(final EncryptTable
encryptTable, final ColumnProjection column, final ShorthandProjectionSegment
segment) {
+ String encryptColumnName =
encryptTable.getCipherColumn(column.getName());
IdentifierValue owner = (null == segment ||
!segment.getOwner().isPresent()) ? column.getOwnerIdentifier() :
segment.getOwner().get().getIdentifier();
return new ColumnProjection(owner, new
IdentifierValue(encryptColumnName,
column.getNameIdentifier().getQuoteCharacter()), column.getAlias().isPresent()
? column.getAliasIdentifier()
: column.getNameIdentifier());
}
- private String getEncryptColumnName(final String tableName, final String
logicEncryptColumnName) {
- return encryptRule.getCipherColumn(tableName, logicEncryptColumnName);
- }
-
private ShorthandProjection getShorthandProjection(final
ShorthandProjectionSegment segment, final ProjectionsContext
projectionsContext) {
Optional<String> owner = segment.getOwner().isPresent() ?
Optional.of(segment.getOwner().get().getIdentifier().getValue()) :
Optional.empty();
for (Projection each : projectionsContext.getProjections()) {
diff --git
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/EncryptInsertOnUpdateTokenGeneratorTest.java
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/EncryptInsertOnUpdateTokenGeneratorTest.java
index 16b8e0eecc7..f58011c2599 100644
---
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/EncryptInsertOnUpdateTokenGeneratorTest.java
+++
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/EncryptInsertOnUpdateTokenGeneratorTest.java
@@ -21,6 +21,7 @@ import
org.apache.shardingsphere.encrypt.api.encrypt.standard.StandardEncryptAlg
import
org.apache.shardingsphere.encrypt.rewrite.token.generator.EncryptInsertOnUpdateTokenGenerator;
import
org.apache.shardingsphere.encrypt.rewrite.token.pojo.EncryptAssignmentToken;
import org.apache.shardingsphere.encrypt.rule.EncryptRule;
+import org.apache.shardingsphere.encrypt.rule.EncryptTable;
import
org.apache.shardingsphere.infra.binder.statement.dml.InsertStatementContext;
import
org.apache.shardingsphere.infra.binder.statement.dml.SelectStatementContext;
import org.apache.shardingsphere.infra.rewrite.sql.token.pojo.SQLToken;
@@ -54,23 +55,30 @@ import static org.mockito.Mockito.when;
class EncryptInsertOnUpdateTokenGeneratorTest {
- private EncryptInsertOnUpdateTokenGenerator generator;
+ private final EncryptInsertOnUpdateTokenGenerator generator = new
EncryptInsertOnUpdateTokenGenerator();
@BeforeEach
void setup() {
- generator = new EncryptInsertOnUpdateTokenGenerator();
generator.setEncryptRule(mockEncryptRule());
}
private EncryptRule mockEncryptRule() {
EncryptRule result = mock(EncryptRule.class);
- when(result.getCipherColumn("t_user",
"mobile")).thenReturn("cipher_mobile");
+ EncryptTable encryptTable = mockEncryptTable();
+
when(result.findEncryptTable("t_user")).thenReturn(Optional.of(encryptTable));
when(result.findStandardEncryptor("t_user",
"mobile")).thenReturn(Optional.of(mock(StandardEncryptAlgorithm.class)));
when(result.findStandardEncryptor("t_user",
"cipher_mobile")).thenReturn(Optional.of(mock(StandardEncryptAlgorithm.class)));
when(result.encrypt(null, "db_test", "t_user", "mobile",
Collections.singletonList(0))).thenReturn(Collections.singletonList("encryptValue"));
return result;
}
+ private static EncryptTable mockEncryptTable() {
+ EncryptTable result = mock(EncryptTable.class);
+ when(result.getTable()).thenReturn("t_user");
+ when(result.getCipherColumn("mobile")).thenReturn("cipher_mobile");
+ return result;
+ }
+
@Test
void assertIsNotGenerateSQLTokenWithNotInsertStatement() {
assertFalse(generator.isGenerateSQLToken(mock(SelectStatementContext.class)));
diff --git
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptProjectionTokenGeneratorTest.java
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptProjectionTokenGeneratorTest.java
index c7f05eb366b..d4d9bb9bf67 100644
---
a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptProjectionTokenGeneratorTest.java
+++
b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/rewrite/token/generator/EncryptProjectionTokenGeneratorTest.java
@@ -51,11 +51,10 @@ import static org.mockito.Mockito.when;
class EncryptProjectionTokenGeneratorTest {
- private EncryptProjectionTokenGenerator generator;
+ private final EncryptProjectionTokenGenerator generator = new
EncryptProjectionTokenGenerator();
@BeforeEach
void setup() {
- generator = new EncryptProjectionTokenGenerator();
generator.setEncryptRule(mockEncryptRule());
generator.setDatabaseName("db_schema");
generator.setSchemas(Collections.singletonMap("test",
mock(ShardingSphereSchema.class)));
@@ -65,8 +64,8 @@ class EncryptProjectionTokenGeneratorTest {
EncryptRule result = mock(EncryptRule.class);
EncryptTable encryptTable1 = mock(EncryptTable.class);
EncryptTable encryptTable2 = mock(EncryptTable.class);
-
when(encryptTable1.getLogicColumns()).thenReturn(Collections.singletonList("mobile"));
-
when(encryptTable2.getLogicColumns()).thenReturn(Collections.singletonList("mobile"));
+
when(encryptTable1.getLogicColumns()).thenReturn(Collections.singleton("mobile"));
+
when(encryptTable2.getLogicColumns()).thenReturn(Collections.singleton("mobile"));
when(result.findEncryptTable("doctor")).thenReturn(Optional.of(encryptTable1));
when(result.findEncryptTable("doctor1")).thenReturn(Optional.of(encryptTable2));
EncryptColumn column = new EncryptColumn("mobile", new
EncryptColumnItem("mobile", "standard_encryptor"));
