Minor changes for code style (#7055)

* Decouple AuthenticationEngine and BackendConnection

* Decouple AuthenticationEngine and BackendConnection

* revise java doc

* Add generic type for JDBCDatabaseCommunicationEngine

* Add generic type for ExecutionContext

* Add generic type for JDBCExecuteEngine

* Refactor JDBCExecutorWrapper

* Refactor JDBCExecutorWrapper

* Refactor StatementExecutorWrapper

* For code format

shardingsphere-infra/shardingsphere-infra-executor/src/main/java/org/apache/shardingsphere/infra/executor/sql/context/ExecutionContext.java

@@ -31,11 +31,11 @@ import java.util.Collections;
 @Getter
 public final class ExecutionContext {
     
-    private final SQLStatementContext sqlStatementContext;
+    private final SQLStatementContext<?> sqlStatementContext;
     
     private final Collection<ExecutionUnit> executionUnits;
     
-    public ExecutionContext(final SQLStatementContext sqlStatementContext, final ExecutionUnit executionUnit) {
+    public ExecutionContext(final SQLStatementContext<?> sqlStatementContext, final ExecutionUnit executionUnit) {
         this(sqlStatementContext, Collections.singletonList(executionUnit));
     }
 }

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

@@ -97,7 +97,7 @@ public final class JDBCDatabaseCommunicationEngine implements DatabaseCommunicat
         if (executionContext.getExecutionUnits().isEmpty()) {
             return new UpdateResponse();
         }
-        SQLStatementContext sqlStatementContext = executionContext.getSqlStatementContext();
+        SQLStatementContext<?> sqlStatementContext = executionContext.getSqlStatementContext();
         if (isExecuteDDLInXATransaction(sqlStatementContext.getSqlStatement())) {
             return new ErrorResponse(new TableModifyInTransactionException(getTableName(sqlStatementContext)));
         }
@@ -110,7 +110,7 @@ public final class JDBCDatabaseCommunicationEngine implements DatabaseCommunicat
         return TransactionType.XA == connection.getTransactionType() && sqlStatement instanceof DDLStatement && ConnectionStatus.TRANSACTION == connection.getStateHandler().getStatus();
     }
     
-    private String getTableName(final SQLStatementContext sqlStatementContext) {
+    private String getTableName(final SQLStatementContext<?> sqlStatementContext) {
         if (sqlStatementContext instanceof TableAvailable) {
             if (((TableAvailable) sqlStatementContext).getAllTables().isEmpty()) {
                 return "unknown_table";
@@ -121,7 +121,7 @@ public final class JDBCDatabaseCommunicationEngine implements DatabaseCommunicat
     }
     
     @SuppressWarnings("unchecked")
-    private void refreshTableMetaData(final SQLStatementContext sqlStatementContext) throws SQLException {
+    private void refreshTableMetaData(final SQLStatementContext<?> sqlStatementContext) throws SQLException {
         if (null == sqlStatementContext) {
             return;
         }
@@ -139,7 +139,7 @@ public final class JDBCDatabaseCommunicationEngine implements DatabaseCommunicat
                 schema.getSchema().getDataSources(), tableName, ProxySchemaContexts.getInstance().getSchemaContexts().getProps());
     }
     
-    private BackendResponse merge(final SQLStatementContext sqlStatementContext) throws SQLException {
+    private BackendResponse merge(final SQLStatementContext<?> sqlStatementContext) throws SQLException {
         if (response instanceof UpdateResponse) {
             mergeUpdateCount(sqlStatementContext);
             return response;
@@ -148,18 +148,18 @@ public final class JDBCDatabaseCommunicationEngine implements DatabaseCommunicat
         return response;
     }
     
-    private void mergeUpdateCount(final SQLStatementContext sqlStatementContext) {
+    private void mergeUpdateCount(final SQLStatementContext<?> sqlStatementContext) {
         if (isNeedAccumulate(sqlStatementContext)) {
             ((UpdateResponse) response).mergeUpdateCount();
         }
     }
     
-    private boolean isNeedAccumulate(final SQLStatementContext sqlStatementContext) {
+    private boolean isNeedAccumulate(final SQLStatementContext<?> sqlStatementContext) {
         Optional<DataNodeRoutedRule> dataNodeRoutedRule = schema.getSchema().getRules().stream().filter(each -> each instanceof DataNodeRoutedRule).findFirst().map(rule -> (DataNodeRoutedRule) rule);
         return dataNodeRoutedRule.isPresent() && dataNodeRoutedRule.get().isNeedAccumulate(sqlStatementContext.getTablesContext().getTableNames());
     }
     
-    private MergedResult mergeQuery(final SQLStatementContext sqlStatementContext, final List<QueryResult> queryResults) throws SQLException {
+    private MergedResult mergeQuery(final SQLStatementContext<?> sqlStatementContext, final List<QueryResult> queryResults) throws SQLException {
         MergeEngine mergeEngine = new MergeEngine(ProxySchemaContexts.getInstance().getSchemaContexts().getDatabaseType(),
                 schema.getSchema().getMetaData().getSchema().getConfiguredSchemaMetaData(), ProxySchemaContexts.getInstance().getSchemaContexts().getProps(), schema.getSchema().getRules());
         return mergeEngine.merge(queryResults, sqlStatementContext);

shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/communication/jdbc/execute/engine/jdbc/JDBCExecuteEngine.java

@@ -83,7 +83,7 @@ public final class JDBCExecuteEngine implements SQLExecuteEngine {
     @SuppressWarnings("unchecked")
     @Override
     public BackendResponse execute(final ExecutionContext executionContext) throws SQLException {
-        SQLStatementContext sqlStatementContext = executionContext.getSqlStatementContext();
+        SQLStatementContext<?> sqlStatementContext = executionContext.getSqlStatementContext();
         boolean isReturnGeneratedKeys = sqlStatementContext.getSqlStatement() instanceof InsertStatement;
         boolean isExceptionThrown = ExecutorExceptionHandler.isExceptionThrown();
         Collection<ExecuteResult> executeResults;

shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/communication/jdbc/wrapper/JDBCExecutorWrapper.java

@@ -57,5 +57,5 @@ public interface JDBCExecutorWrapper {
      * @param option statement option
      * @return execute group engine
      */
-    ExecuteGroupEngine getExecuteGroupEngine(BackendConnection backendConnection, StatementOption option);
+    ExecuteGroupEngine<?> getExecuteGroupEngine(BackendConnection backendConnection, StatementOption option);
 }

shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/communication/jdbc/wrapper/PreparedStatementExecutorWrapper.java

@@ -80,7 +80,7 @@ public final class PreparedStatementExecutorWrapper implements JDBCExecutorWrapp
     }
     
     @Override
-    public ExecuteGroupEngine getExecuteGroupEngine(final BackendConnection backendConnection, final StatementOption option) {
+    public ExecuteGroupEngine<?> getExecuteGroupEngine(final BackendConnection backendConnection, final StatementOption option) {
         int maxConnectionsSizePerQuery = PROXY_SCHEMA_CONTEXTS.getSchemaContexts().getProps().<Integer>getValue(ConfigurationPropertyKey.MAX_CONNECTIONS_SIZE_PER_QUERY);
         return new PreparedStatementExecuteGroupEngine(maxConnectionsSizePerQuery, backendConnection, option, schema.getSchema().getRules());
     }

shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/communication/jdbc/wrapper/StatementExecutorWrapper.java

@@ -55,15 +55,14 @@ public final class StatementExecutorWrapper implements JDBCExecutorWrapper {
     
     private final SQLStatement sqlStatement;
     
-    @SuppressWarnings("unchecked")
     @Override
     public ExecutionContext execute(final String sql) {
         Collection<ShardingSphereRule> rules = schema.getSchema().getRules();
         if (rules.isEmpty()) {
             return createExecutionContext(sql);
         }
-        RouteContext routeContext = 
-                new DataNodeRouter(schema.getSchema().getMetaData(), PROXY_SCHEMA_CONTEXTS.getSchemaContexts().getProps(), rules).route(sqlStatement, sql, Collections.emptyList());
+        DataNodeRouter router = new DataNodeRouter(schema.getSchema().getMetaData(), PROXY_SCHEMA_CONTEXTS.getSchemaContexts().getProps(), rules);
+        RouteContext routeContext = router.route(sqlStatement, sql, Collections.emptyList());
         routeMetricsCollect(routeContext, rules);
         SQLRewriteResult sqlRewriteResult = new SQLRewriteEntry(schema.getSchema().getMetaData().getSchema().getConfiguredSchemaMetaData(),
                 PROXY_SCHEMA_CONTEXTS.getSchemaContexts().getProps(), rules).rewrite(sql, Collections.emptyList(), routeContext);
@@ -75,20 +74,20 @@ public final class StatementExecutorWrapper implements JDBCExecutorWrapper {
         return statement.execute(sql, isReturnGeneratedKeys ? Statement.RETURN_GENERATED_KEYS : Statement.NO_GENERATED_KEYS);
     }
     
+    @SuppressWarnings("unchecked")
     private ExecutionContext createExecutionContext(final String sql) {
         String dataSource = schema.getSchema().getDataSources().isEmpty() ? "" : schema.getSchema().getDataSources().keySet().iterator().next();
-        return new ExecutionContext(
-                new CommonSQLStatementContext(sqlStatement), new ExecutionUnit(dataSource, new SQLUnit(sql, Collections.emptyList())));
-    }
-    
-    @Override
-    public ExecuteGroupEngine getExecuteGroupEngine(final BackendConnection backendConnection, final StatementOption option) {
-        int maxConnectionsSizePerQuery = PROXY_SCHEMA_CONTEXTS.getSchemaContexts().getProps().<Integer>getValue(ConfigurationPropertyKey.MAX_CONNECTIONS_SIZE_PER_QUERY);
-        return new StatementExecuteGroupEngine(maxConnectionsSizePerQuery, backendConnection, option, schema.getSchema().getRules());
+        return new ExecutionContext(new CommonSQLStatementContext(sqlStatement), new ExecutionUnit(dataSource, new SQLUnit(sql, Collections.emptyList())));
     }
     
     private void routeMetricsCollect(final RouteContext routeContext, final Collection<ShardingSphereRule> rules) {
         MetricsUtils.buriedShardingMetrics(routeContext.getRouteResult().getRouteUnits());
         MetricsUtils.buriedShardingRuleMetrics(routeContext, rules);
     }
+    
+    @Override
+    public ExecuteGroupEngine<?> getExecuteGroupEngine(final BackendConnection backendConnection, final StatementOption option) {
+        int maxConnectionsSizePerQuery = PROXY_SCHEMA_CONTEXTS.getSchemaContexts().getProps().<Integer>getValue(ConfigurationPropertyKey.MAX_CONNECTIONS_SIZE_PER_QUERY);
+        return new StatementExecuteGroupEngine(maxConnectionsSizePerQuery, backendConnection, option, schema.getSchema().getRules());
+    }
 }

shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/metrics/MetricsUtils.java

@@ -77,4 +77,3 @@ public final class MetricsUtils {
         }));
     }
 }
-

shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/TextProtocolBackendHandlerFactory.java

@@ -67,7 +67,7 @@ public final class TextProtocolBackendHandlerFactory {
         if (Strings.isNullOrEmpty(sql)) {
             return new SkipBackendHandler();
         }
-        // TODO : Parse sctl sql with Antlr.
+        // TODO Parse sctl SQL with ANTLR
         String trimSQL = SCTLUtils.trimComment(sql);
         if (trimSQL.toUpperCase().startsWith(ShardingCTLBackendHandlerFactory.SCTL)) {
             return ShardingCTLBackendHandlerFactory.newInstance(trimSQL, backendConnection);

shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/admin/RDLBackendHandler.java

@@ -54,7 +54,7 @@ import java.util.Collections;
 import java.util.Map;
 
 /**
- * Backer handler for rdl.
+ * Backer handler for RDL.
  */
 @RequiredArgsConstructor
 public final class RDLBackendHandler implements TextProtocolBackendHandler {
@@ -65,7 +65,7 @@ public final class RDLBackendHandler implements TextProtocolBackendHandler {
     
     @Override
     public BackendResponse execute() {
-        SQLStatementContext context = getSqlStatementContext();
+        SQLStatementContext<?> context = getSQLStatementContext();
         if (!isRegistryCenterExisted()) {
             return new ErrorResponse(new SQLException("No Registry center to execute `%s` SQL", context.getClass().getSimpleName()));
         }
@@ -103,7 +103,7 @@ public final class RDLBackendHandler implements TextProtocolBackendHandler {
         return result;
     }
     
-    private SQLStatementContext<?> getSqlStatementContext() {
+    private SQLStatementContext<?> getSQLStatementContext() {
         DatabaseType databaseType = ProxySchemaContexts.getInstance().getSchemaContexts().getDatabaseType();
         if (sqlStatement instanceof CreateDataSourcesStatement) {
             return new CreateDataSourcesStatementContext((CreateDataSourcesStatement) sqlStatement, databaseType);
@@ -113,7 +113,7 @@ public final class RDLBackendHandler implements TextProtocolBackendHandler {
         return new CreateDatabaseStatementContext((CreateDatabaseStatement) sqlStatement);
     }
     
-    private BackendResponse getBackendResponse(final SQLStatementContext context) {
+    private BackendResponse getBackendResponse(final SQLStatementContext<?> context) {
         if (context instanceof CreateDatabaseStatementContext) {
             return execute((CreateDatabaseStatementContext) context);
         }