How to use

getSqlStatement

method

in

org.apache.shardingsphere.core.routing.SQLRouteResult

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

  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));
}

@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 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;
}

/**
 * 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();
}

/**
 * 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 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);
}

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

@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);
}

@Override
public int executeUpdate(final String sql) throws SQLException {
  try {
    clearPrevious();
    sqlRoute(sql);
    initStatementExecutor();
    return statementExecutor.executeUpdate();
  } finally {
    refreshTableMetaData(connection.getShardingContext(), routeResult.getSqlStatement());
    currentResultSet = null;
  }
}

@Override
public boolean execute(final String sql) throws SQLException {
  try {
    clearPrevious();
    sqlRoute(sql);
    initStatementExecutor();
    return statementExecutor.execute();
  } finally {
    refreshTableMetaData(connection.getShardingContext(), routeResult.getSqlStatement());
    currentResultSet = null;
  }
}

@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);
}

@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).getQueryResponsePackets(), executeResponseUnits) : new ExecuteUpdateResponse(executeResponseUnits);
}

@Override
public int executeUpdate() throws SQLException {
  try {
    clearPrevious();
    sqlRoute();
    initPreparedStatementExecutor();
    return preparedStatementExecutor.executeUpdate();
  } finally {
    refreshTableMetaData(connection.getShardingContext(), routeResult.getSqlStatement());
    clearBatch();
  }
}

@Override
public boolean execute() throws SQLException {
  try {
    clearPrevious();
    sqlRoute();
    initPreparedStatementExecutor();
    return preparedStatementExecutor.execute();
  } finally {
    refreshTableMetaData(connection.getShardingContext(), routeResult.getSqlStatement());
    clearBatch();
  }
}

private CommandResponsePackets execute(final SQLRouteResult routeResult) throws SQLException {
  if (routeResult.getRouteUnits().isEmpty()) {
    return new CommandResponsePackets(new OKPacket(1));
  }
  SQLStatement sqlStatement = routeResult.getSqlStatement();
  if (isUnsupportedXA(sqlStatement.getType())) {
    return new CommandResponsePackets(new ErrPacket(1,
        ServerErrorCode.ER_ERROR_ON_MODIFYING_GTID_EXECUTED_TABLE, sqlStatement.getTables().isSingleTable() ? sqlStatement.getTables().getSingleTableName() : "unknown_table"));
  }
  executeResponse = executeEngine.execute(routeResult);
  if (logicSchema instanceof ShardingSchema) {
    logicSchema.refreshTableMetaData(routeResult.getSqlStatement());
  }
  return merge(sqlStatement);
}

@Override
public ResultSet executeQuery(final String sql) throws SQLException {
  ResultSet result;
  try {
    clearPrevious();
    sqlRoute(sql);
    initStatementExecutor();
    MergeEngine mergeEngine = MergeEngineFactory.newInstance(connection.getShardingContext().getDatabaseType(), connection.getShardingContext().getShardingRule(), 
        routeResult.getSqlStatement(), connection.getShardingContext().getMetaData().getTable(), statementExecutor.executeQuery());
    result = new ShardingResultSet(statementExecutor.getResultSets(), mergeEngine.merge(), this);
  } finally {
    currentResultSet = null;
  }
  currentResultSet = result;
  return result;
}

@Override
public ResultSet executeQuery() throws SQLException {
  ResultSet result;
  try {
    clearPrevious();
    sqlRoute();
    initPreparedStatementExecutor();
    MergeEngine mergeEngine = MergeEngineFactory.newInstance(connection.getShardingContext().getDatabaseType(), connection.getShardingContext().getShardingRule(), 
        routeResult.getSqlStatement(), connection.getShardingContext().getMetaData().getTable(), preparedStatementExecutor.executeQuery());
    result = new ShardingResultSet(preparedStatementExecutor.getResultSets(), mergeEngine.merge(), this);
  } finally {
    clearBatch();
  }
  currentResultSet = result;
  return result;
}