How to use

SQLRouteResult

in

org.apache.shardingsphere.core.routing

/**
 * Initialize executor.
 *
 * @param routeResult route result
 * @throws SQLException SQL exception
 */
public void init(final SQLRouteResult routeResult) throws SQLException {
  setSqlStatement(routeResult.getSqlStatement());
  getExecuteGroups().addAll(obtainExecuteGroups(routeResult.getRouteUnits()));
  cacheStatements();
}

  @Override
  // TODO insert SQL need parse gen key
  public SQLRouteResult route(final String logicSQL, final List<Object> parameters, final SQLStatement sqlStatement) {
    SQLRouteResult result = new SQLRouteResult(sqlStatement);
    RoutingResult routingResult = new DatabaseHintRoutingEngine(
        shardingRule.getShardingDataSourceNames().getDataSourceNames(), (HintShardingStrategy) shardingRule.getDefaultDatabaseShardingStrategy()).route();
    for (TableUnit each : routingResult.getTableUnits().getTableUnits()) {
      result.getRouteUnits().add(new RouteUnit(each.getDataSourceName(), new SQLUnit(logicSQL, new ArrayList<>(Collections.singleton(parameters)))));
    }
    if (showSQL) {
      SQLLogger.logSQL(logicSQL, sqlStatement, result.getRouteUnits());
    }
    return result;
  }
}

private Optional<GeneratedKey> getGeneratedKey() {
  if (null != routeResult && routeResult.getSqlStatement() instanceof InsertStatement) {
    return Optional.fromNullable(routeResult.getGeneratedKey());
  }
  return Optional.absent();
}

/**
 * Initialize executor.
 *
 * @param routeResult route result
 * @throws SQLException SQL exception
 */
public void init(final SQLRouteResult routeResult) throws SQLException {
  setSqlStatement(routeResult.getSqlStatement());
  getExecuteGroups().addAll(obtainExecuteGroups(routeUnits));
}

/**
 * Add batch for route units.
 *
 * @param routeResult route result
 */
public void addBatchForRouteUnits(final SQLRouteResult routeResult) {
  handleOldRouteUnits(createBatchRouteUnits(routeResult.getRouteUnits()));
  handleNewRouteUnits(createBatchRouteUnits(routeResult.getRouteUnits()));
  batchCount++;
}

private void setGeneratedKeys(final SQLRouteResult sqlRouteResult, final GeneratedKey generatedKey) {
  generatedKeys.addAll(generatedKey.getGeneratedKeys());
  sqlRouteResult.getGeneratedKey().getGeneratedKeys().clear();
  sqlRouteResult.getGeneratedKey().getGeneratedKeys().addAll(generatedKeys);
}

@Override
public ResultSet getResultSet() throws SQLException {
  if (null != currentResultSet) {
    return currentResultSet;
  }
  if (1 == statementExecutor.getStatements().size() && routeResult.getSqlStatement() instanceof DQLStatement) {
    currentResultSet = statementExecutor.getStatements().iterator().next().getResultSet();
    return currentResultSet;
  }
  List<ResultSet> resultSets = new ArrayList<>(statementExecutor.getStatements().size());
  List<QueryResult> queryResults = new ArrayList<>(statementExecutor.getStatements().size());
  for (Statement each : statementExecutor.getStatements()) {
    ResultSet resultSet = each.getResultSet();
    resultSets.add(resultSet);
    queryResults.add(new StreamQueryResult(resultSet));
  }
  if (routeResult.getSqlStatement() instanceof SelectStatement || routeResult.getSqlStatement() instanceof DALStatement) {
    MergeEngine mergeEngine = MergeEngineFactory.newInstance(connection.getShardingContext().getDatabaseType(), 
        connection.getShardingContext().getShardingRule(), routeResult.getSqlStatement(), connection.getShardingContext().getMetaData().getTable(), queryResults);
    currentResultSet = new ShardingResultSet(resultSets, mergeEngine.merge(), this);
  }
  return currentResultSet;
}

@Override
public ResultSet getGeneratedKeys() throws SQLException {
  Optional<GeneratedKey> generatedKey = getGeneratedKey();
  if (returnGeneratedKeys && generatedKey.isPresent()) {
    return new GeneratedKeysResultSet(routeResult.getGeneratedKey().getGeneratedKeys().iterator(), generatedKey.get().getColumn().getName(), this);
  }
  if (1 == getRoutedStatements().size()) {
    return getRoutedStatements().iterator().next().getGeneratedKeys();
  }
  return new GeneratedKeysResultSet();
}

/**
 * Initialize executor.
 *
 * @param routeResult route result
 * @throws SQLException SQL exception
 */
public void init(final SQLRouteResult routeResult) throws SQLException {
  setSqlStatement(routeResult.getSqlStatement());
  getExecuteGroups().addAll(obtainExecuteGroups(routeResult.getRouteUnits()));
  cacheStatements();
}

private SQLRouteResult doMasterSlaveRoute(final String sql) {
  SQLStatement sqlStatement = new SQLJudgeEngine(sql).judge();
  String rewriteSQL = new MasterSlaveSQLRewriteEngine(((MasterSlaveSchema) logicSchema).getMasterSlaveRule(), sql, sqlStatement, logicSchema.getMetaData()).rewrite();
  SQLRouteResult result = new SQLRouteResult(sqlStatement);
  for (String each : new MasterSlaveRouter(
      ((MasterSlaveSchema) logicSchema).getMasterSlaveRule(), GLOBAL_REGISTRY.getShardingProperties().<Boolean>getValue(ShardingPropertiesConstant.SQL_SHOW)).route(rewriteSQL)) {
    result.getRouteUnits().add(new RouteUnit(each, new SQLUnit(rewriteSQL, new ArrayList<>(Collections.singleton(parameters)))));
  }
  return result;
}

@Override
public ResultSet getResultSet() throws SQLException {
  if (null != currentResultSet) {
    return currentResultSet;
  }
  if (1 == preparedStatementExecutor.getStatements().size() && routeResult.getSqlStatement() instanceof DQLStatement) {
    currentResultSet = preparedStatementExecutor.getStatements().iterator().next().getResultSet();
    return currentResultSet;
  }
  List<ResultSet> resultSets = new ArrayList<>(preparedStatementExecutor.getStatements().size());
  List<QueryResult> queryResults = new ArrayList<>(preparedStatementExecutor.getStatements().size());
  for (Statement each : preparedStatementExecutor.getStatements()) {
    ResultSet resultSet = each.getResultSet();
    resultSets.add(resultSet);
    queryResults.add(new StreamQueryResult(resultSet));
  }
  if (routeResult.getSqlStatement() instanceof SelectStatement || routeResult.getSqlStatement() instanceof DALStatement) {
    MergeEngine mergeEngine = MergeEngineFactory.newInstance(connection.getShardingContext().getDatabaseType(), 
        connection.getShardingContext().getShardingRule(), routeResult.getSqlStatement(), connection.getShardingContext().getMetaData().getTable(), queryResults);
    currentResultSet = new ShardingResultSet(resultSets, mergeEngine.merge(), this);
  }
  return currentResultSet;
}

  private Optional<GeneratedKey> getGeneratedKey() {
    if (null != routeResult && routeResult.getSqlStatement() instanceof InsertStatement) {
      return Optional.fromNullable(routeResult.getGeneratedKey());
    }
    return Optional.absent();
  }
}

@Override
public ResultSet getGeneratedKeys() throws SQLException {
  Optional<GeneratedKey> generatedKey = getGeneratedKey();
  if (preparedStatementExecutor.isReturnGeneratedKeys() && generatedKey.isPresent()) {
    return new GeneratedKeysResultSet(routeResult.getGeneratedKey().getGeneratedKeys().iterator(), generatedKey.get().getColumn().getName(), this);
  }
  if (1 == preparedStatementExecutor.getStatements().size()) {
    return preparedStatementExecutor.getStatements().iterator().next().getGeneratedKeys();
  }
  return new GeneratedKeysResultSet();
}

private void route(final MasterSlaveRule masterSlaveRule, final SQLRouteResult sqlRouteResult) {
  Collection<RouteUnit> toBeRemoved = new LinkedList<>();
  Collection<RouteUnit> toBeAdded = new LinkedList<>();
  for (RouteUnit each : sqlRouteResult.getRouteUnits()) {
    if (!masterSlaveRule.getName().equalsIgnoreCase(each.getDataSourceName())) {
      continue;
    }
    toBeRemoved.add(each);
    if (isMasterRoute(sqlRouteResult.getSqlStatement().getType())) {
      MasterVisitedManager.setMasterVisited();
      toBeAdded.add(new RouteUnit(masterSlaveRule.getMasterDataSourceName(), each.getSqlUnit()));
    } else {
      toBeAdded.add(new RouteUnit(masterSlaveRule.getLoadBalanceAlgorithm().getDataSource(
        masterSlaveRule.getName(), masterSlaveRule.getMasterDataSourceName(), new ArrayList<>(masterSlaveRule.getSlaveDataSourceNames())), each.getSqlUnit()));
    }
  }
  sqlRouteResult.getRouteUnits().removeAll(toBeRemoved);
  sqlRouteResult.getRouteUnits().addAll(toBeAdded);
}

private SQLRouteResult doMasterSlaveRoute(final String sql) {
  SQLStatement sqlStatement = new SQLJudgeEngine(sql).judge();
  String rewriteSQL = new MasterSlaveSQLRewriteEngine(((MasterSlaveSchema) logicSchema).getMasterSlaveRule(), sql, sqlStatement, logicSchema.getMetaData()).rewrite();
  SQLRouteResult result = new SQLRouteResult(sqlStatement);
  for (String each : new MasterSlaveRouter(
      ((MasterSlaveSchema) logicSchema).getMasterSlaveRule(), GLOBAL_REGISTRY.getShardingProperties().<Boolean>getValue(ShardingPropertiesConstant.SQL_SHOW)).route(rewriteSQL)) {
    result.getRouteUnits().add(new RouteUnit(each, new SQLUnit(rewriteSQL, new ArrayList<>(Collections.singleton(parameters)))));
  }
  return result;
}

@Override
public boolean isAccumulate() {
  return !connection.getShardingContext().getShardingRule().isAllBroadcastTables(routeResult.getSqlStatement().getTables().getTableNames());
}

private PostgreSQLCommandResponsePackets execute(final SQLRouteResult routeResult) throws SQLException {
  if (routeResult.getRouteUnits().isEmpty()) {
    return new PostgreSQLCommandResponsePackets(new OKPacket(1));
  }
  SQLStatement sqlStatement = routeResult.getSqlStatement();
  if (isUnsupportedXA(sqlStatement.getType())) {
    return new PostgreSQLCommandResponsePackets(new PostgreSQLErrorResponsePacket());
  }
  executeResponse = executeEngine.execute(routeResult);
  if (logicSchema instanceof ShardingSchema) {
    logicSchema.refreshTableMetaData(routeResult.getSqlStatement());
  }
  return merge(sqlStatement);
}

private SQLRouteResult doMasterSlaveRoute(final String sql) {
  SQLStatement sqlStatement = new SQLJudgeEngine(sql).judge();
  String rewriteSQL = new MasterSlaveSQLRewriteEngine(((MasterSlaveSchema) logicSchema).getMasterSlaveRule(), sql, sqlStatement, logicSchema.getMetaData()).rewrite();
  SQLRouteResult result = new SQLRouteResult(sqlStatement);
  for (String each : new MasterSlaveRouter(
      ((MasterSlaveSchema) logicSchema).getMasterSlaveRule(), GLOBAL_REGISTRY.getShardingProperties().<Boolean>getValue(ShardingPropertiesConstant.SQL_SHOW)).route(rewriteSQL)) {
    result.getRouteUnits().add(new RouteUnit(each, new SQLUnit(rewriteSQL, Collections.<List<Object>>emptyList())));
  }
  return result;
}

@Override
public boolean isAccumulate() {
  return !connection.getShardingContext().getShardingRule().isAllBroadcastTables(routeResult.getSqlStatement().getTables().getTableNames());
}

@SuppressWarnings("unchecked")
@Override
public ExecuteResponse execute(final SQLRouteResult routeResult) throws SQLException {
  boolean isReturnGeneratedKeys = routeResult.getSqlStatement() instanceof InsertStatement;
  boolean isExceptionThrown = ExecutorExceptionHandler.isExceptionThrown();
  Collection<ShardingExecuteGroup<StatementExecuteUnit>> sqlExecuteGroups =
    sqlExecutePrepareTemplate.getExecuteUnitGroups(routeResult.getRouteUnits(), new ProxyJDBCExecutePrepareCallback(isReturnGeneratedKeys));
  SQLExecuteCallback<ExecuteResponseUnit> firstProxySQLExecuteCallback = new FirstProxyJDBCExecuteCallback(isExceptionThrown, isReturnGeneratedKeys);
  SQLExecuteCallback<ExecuteResponseUnit> proxySQLExecuteCallback = new ProxyJDBCExecuteCallback(isExceptionThrown, isReturnGeneratedKeys);
  Collection<ExecuteResponseUnit> executeResponseUnits = sqlExecuteTemplate.executeGroup((Collection) sqlExecuteGroups,
    firstProxySQLExecuteCallback, proxySQLExecuteCallback);
  ExecuteResponseUnit firstExecuteResponseUnit = executeResponseUnits.iterator().next();
  return firstExecuteResponseUnit instanceof ExecuteQueryResponseUnit
    ? getExecuteQueryResponse(((ExecuteQueryResponseUnit) firstExecuteResponseUnit).getPostgreSQLQueryResponsePackets(), executeResponseUnits)
    : new ExecuteUpdateResponse(executeResponseUnits);
}