How to use

getTable

method

in

org.apache.shardingsphere.core.metadata.ShardingMetaData

private void refreshTableMetaData(final AlterTableStatement alterTableStatement) {
  String logicTableName = alterTableStatement.getTables().getSingleTableName();
  TableMetaData newTableMetaData = TableMetaDataFactory.newInstance(alterTableStatement, getMetaData().getTable().get(logicTableName));
  Optional<String> newTableName = alterTableStatement.getNewTableName();
  if (newTableName.isPresent()) {
    getMetaData().getTable().put(newTableName.get(), newTableMetaData);
    getMetaData().getTable().remove(logicTableName);
  } else {
    getMetaData().getTable().put(logicTableName, newTableMetaData);
  }
}

private void refreshTableMetaData(final ShardingContext shardingContext, final AlterTableStatement alterTableStatement) {
  String logicTableName = alterTableStatement.getTables().getSingleTableName();
  TableMetaData newTableMetaData = TableMetaDataFactory.newInstance(alterTableStatement, shardingContext.getMetaData().getTable().get(logicTableName));
  Optional<String> newTableName = alterTableStatement.getNewTableName();
  if (newTableName.isPresent()) {
    shardingContext.getMetaData().getTable().put(newTableName.get(), newTableMetaData);
    shardingContext.getMetaData().getTable().remove(logicTableName);
  } else {
    shardingContext.getMetaData().getTable().put(logicTableName, newTableMetaData);
  }
}

private void refreshTableMetaData(final AlterTableStatement alterTableStatement) {
  String logicTableName = alterTableStatement.getTables().getSingleTableName();
  TableMetaData newTableMetaData = TableMetaDataFactory.newInstance(alterTableStatement, getMetaData().getTable().get(logicTableName));
  Optional<String> newTableName = alterTableStatement.getNewTableName();
  if (newTableName.isPresent()) {
    getMetaData().getTable().put(newTableName.get(), newTableMetaData);
    getMetaData().getTable().remove(logicTableName);
  } else {
    getMetaData().getTable().put(logicTableName, newTableMetaData);
  }
}

@Override
public SQLStatement parse(final String logicSQL, final boolean useCache) {
  parsingHook.start(logicSQL);
  try {
    SQLStatement result = new SQLParsingEngine(databaseType, logicSQL, shardingRule, shardingMetaData.getTable()).parse(useCache);
    parsingHook.finishSuccess(result, shardingMetaData.getTable());
    return result;
    // CHECKSTYLE:OFF
  } catch (final Exception ex) {
    // CHECKSTYLE:ON
    parsingHook.finishFailure(ex);
    throw ex;
  }
}

  private void refreshTableMetaData(final DropTableStatement dropTableStatement) {
    for (String each : dropTableStatement.getTables().getTableNames()) {
      getMetaData().getTable().remove(each);
    }
  }
}

  private void refreshTableMetaData(final ShardingContext shardingContext, final DropTableStatement dropTableStatement) {
    for (String each : dropTableStatement.getTables().getTableNames()) {
      shardingContext.getMetaData().getTable().remove(each);
    }
  }
}

  private void refreshTableMetaData(final DropTableStatement dropTableStatement) {
    for (String each : dropTableStatement.getTables().getTableNames()) {
      getMetaData().getTable().remove(each);
    }
  }
}

private PostgreSQLCommandResponsePackets mergeDQLorDAL(final SQLStatement sqlStatement, final List<PostgreSQLCommandResponsePackets> packets, final List<QueryResult> queryResults) {
  try {
    mergedResult = MergeEngineFactory.newInstance(
        DatabaseType.MySQL, ((ShardingSchema) logicSchema).getShardingRule(), sqlStatement, logicSchema.getMetaData().getTable(), queryResults).merge();
  } catch (final SQLException ex) {
    return new PostgreSQLCommandResponsePackets(new ErrPacket(1, ex));
  }
  return packets.get(0);
}

private CommandResponsePackets mergeDQLorDAL(final SQLStatement sqlStatement, final List<CommandResponsePackets> packets, final List<QueryResult> queryResults) {
  try {
    mergedResult = MergeEngineFactory.newInstance(
        DatabaseType.MySQL, ((ShardingSchema) logicSchema).getShardingRule(), sqlStatement, logicSchema.getMetaData().getTable(), queryResults).merge();
  } catch (final SQLException ex) {
    return new CommandResponsePackets(new ErrPacket(1, ex));
  }
  return packets.get(0);
}

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

private void refreshTableMetaData(final ShardingContext shardingContext, final CreateTableStatement createTableStatement) {
  shardingContext.getMetaData().getTable().put(createTableStatement.getTables().getSingleTableName(), TableMetaDataFactory.newInstance(createTableStatement));
}

private void refreshTableMetaData(final CreateTableStatement createTableStatement) {
  getMetaData().getTable().put(createTableStatement.getTables().getSingleTableName(), TableMetaDataFactory.newInstance(createTableStatement));
}

private void refreshTableMetaData(final CreateTableStatement createTableStatement) {
  getMetaData().getTable().put(createTableStatement.getTables().getSingleTableName(), TableMetaDataFactory.newInstance(createTableStatement));
}

public ComStmtPreparePacket(final int sequenceId, final BackendConnection backendConnection, final MySQLPacketPayload payload) {
  this.sequenceId = sequenceId;
  sql = payload.readStringEOF();
  schemaName = backendConnection.getSchemaName();
  LogicSchema logicSchema = backendConnection.getLogicSchema();
  sqlParsingEngine = new SQLParsingEngine(DatabaseType.MySQL, sql, getShardingRule(logicSchema), logicSchema.getMetaData().getTable());
}

public ComStmtPreparePacket(final int sequenceId, final BackendConnection backendConnection, final MySQLPacketPayload payload) {
  this.sequenceId = sequenceId;
  sql = payload.readStringEOF();
  schemaName = backendConnection.getSchemaName();
  LogicSchema logicSchema = backendConnection.getLogicSchema();
  sqlParsingEngine = new SQLParsingEngine(DatabaseType.PostgreSQL, sql, getShardingRule(logicSchema), logicSchema.getMetaData().getTable());
}

public PostgreSQLComParsePacket(final PostgreSQLPacketPayload payload, final BackendConnection backendConnection) {
  postgreSQLBinaryStatementRegistry = backendConnection.getPostgreSQLBinaryStatementRegistry();
  payload.readInt4();
  statementId = payload.readStringNul();
  sql = alterSQLToJDBCStyle(payload.readStringNul());
  if (!sql.isEmpty()) {
    getParameterTypes(payload);
    LogicSchema logicSchema = backendConnection.getLogicSchema();
    sqlParsingEngine = new SQLParsingEngine(DatabaseType.PostgreSQL, sql, getShardingRule(logicSchema), logicSchema.getMetaData().getTable());
  }
}

private CommandResponsePackets merge(final SQLStatement sqlStatement) throws SQLException {
  if (executeResponse instanceof ExecuteUpdateResponse) {
    if (logicSchema instanceof ShardingSchema && ((ShardingSchema) logicSchema).getShardingRule().isAllBroadcastTables(sqlStatement.getTables().getTableNames())) {
      return new CommandResponsePackets(((ExecuteUpdateResponse) executeResponse).getPackets().get(0));
    }
    return ((ExecuteUpdateResponse) executeResponse).merge();
  }
  mergedResult = MergeEngineFactory.newInstance(
      DatabaseType.MySQL, getShardingRule(), sqlStatement, logicSchema.getMetaData().getTable(), ((ExecuteQueryResponse) executeResponse).getQueryResults()).merge();
  if (mergedResult instanceof ShowTablesMergedResult) {
    ((ShowTablesMergedResult) mergedResult).resetColumnLabel(logicSchema.getName());
    setResponseColumnLabelForShowTablesMergedResult(((ExecuteQueryResponse) executeResponse).getQueryResponsePackets());
  }
  QueryResponsePackets result = getQueryResponsePacketsWithoutDerivedColumns(((ExecuteQueryResponse) executeResponse).getQueryResponsePackets());
  currentSequenceId = result.getPackets().size();
  return result;
}

private PostgreSQLCommandResponsePackets merge(final SQLStatement sqlStatement) throws SQLException {
  if (executeResponse instanceof ExecuteUpdateResponse) {
    if (logicSchema instanceof ShardingSchema && ((ShardingSchema) logicSchema).getShardingRule().isAllBroadcastTables(sqlStatement.getTables().getTableNames())) {
      return new PostgreSQLCommandResponsePackets(((ExecuteUpdateResponse) executeResponse).getPackets().get(0));
    }
    return ((ExecuteUpdateResponse) executeResponse).merge();
  }
  mergedResult = MergeEngineFactory.newInstance(
      DatabaseType.PostgreSQL, getShardingRule(), sqlStatement, logicSchema.getMetaData().getTable(), ((ExecuteQueryResponse) executeResponse).getQueryResults()).merge();
  if (mergedResult instanceof ShowTablesMergedResult) {
    ((ShowTablesMergedResult) mergedResult).resetColumnLabel(logicSchema.getName());
    setResponseColumnLabelForShowTablesMergedResult(((ExecuteQueryResponse) executeResponse).getPostgreSQLQueryResponsePackets());
  }
  PostgreSQLQueryResponsePackets result = getQueryResponsePacketsWithoutDerivedColumns(((ExecuteQueryResponse) executeResponse).getPostgreSQLQueryResponsePackets());
  currentSequenceId = result.getPackets().size();
  return result;
}

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