How to use

ShardingMetaData

in

org.apache.shardingsphere.core.metadata

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

public ShardingContext(final Map<String, DataSource> dataSourceMap, final ShardingRule shardingRule, final DatabaseType databaseType, final Properties props) throws SQLException {
  this.cachedDatabaseMetaData = createCachedDatabaseMetaData(dataSourceMap);
  this.shardingRule = shardingRule;
  this.databaseType = databaseType;
  
  shardingProperties = new ShardingProperties(null == props ? new Properties() : props);
  int executorSize = shardingProperties.getValue(ShardingPropertiesConstant.EXECUTOR_SIZE);
  executeEngine = new ShardingExecuteEngine(executorSize);
  metaData = new ShardingMetaData(getDataSourceURLs(dataSourceMap), shardingRule, databaseType, executeEngine, new JDBCTableMetaDataConnectionManager(dataSourceMap), 
      shardingProperties.<Integer>getValue(ShardingPropertiesConstant.MAX_CONNECTIONS_SIZE_PER_QUERY), 
      shardingProperties.<Boolean>getValue(ShardingPropertiesConstant.CHECK_TABLE_METADATA_ENABLED));
}

public MySQLResponseHandler(final String dataSourceName, final String schema) {
  dataSourceParameter = GLOBAL_REGISTRY.getLogicSchema(schema).getDataSources().get(dataSourceName);
  dataSourceMetaData = GLOBAL_REGISTRY.getLogicSchema(schema).getMetaData().getDataSource().getActualDataSourceMetaData(dataSourceName);
  resultMap = new HashMap<>();
}

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

public MySQLResponseHandler(final String dataSourceName, final String schema) {
  dataSourceParameter = GLOBAL_REGISTRY.getLogicSchema(schema).getDataSources().get(dataSourceName);
  dataSourceMetaData = GLOBAL_REGISTRY.getLogicSchema(schema).getMetaData().getDataSource().getActualDataSourceMetaData(dataSourceName);
  resultMap = new HashMap<>();
}

private ShardingMetaData createShardingMetaData(final boolean isCheckingMetaData) {
  return new ShardingMetaData(getDataSourceURLs(getDataSources()), shardingRule, DatabaseType.MySQL, 
      BackendExecutorContext.getInstance().getExecuteEngine(), new ProxyTableMetaDataConnectionManager(getBackendDataSource()), 
      GlobalRegistry.getInstance().getShardingProperties().<Integer>getValue(ShardingPropertiesConstant.MAX_CONNECTIONS_SIZE_PER_QUERY), isCheckingMetaData);
}

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

/**
 * Rewrite SQL.
 * 
 * @return SQL
 */
public String rewrite() {
  if (sqlTokens.isEmpty()) {
    return originalSQL;
  }
  SQLBuilder result = new SQLBuilder(Collections.emptyList());
  int count = 0;
  for (SQLToken each : sqlTokens) {
    if (0 == count) {
      result.appendLiterals(originalSQL.substring(0, each.getStartIndex()));
    }
    if (each instanceof SchemaToken) {
      appendSchemaPlaceholder(originalSQL, result, (SchemaToken) each, count);
    }
    count++;
  }
  return result.toSQL(masterSlaveRule, metaData.getDataSource());
}

private ShardingMetaData createShardingMetaData(final boolean isCheckingMetaData) {
  return new ShardingMetaData(getDataSourceURLs(getDataSources()), shardingRule, DatabaseType.PostgreSQL,
      BackendExecutorContext.getInstance().getExecuteEngine(), new ProxyTableMetaDataConnectionManager(getBackendDataSource()), 
      GlobalRegistry.getInstance().getShardingProperties().<Integer>getValue(ShardingPropertiesConstant.MAX_CONNECTIONS_SIZE_PER_QUERY), isCheckingMetaData);
}

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

@Override
public SQLRouteResult route(final String logicSQL, final List<Object> parameters, final SQLStatement sqlStatement) {
  Optional<GeneratedKey> generatedKey = sqlStatement instanceof InsertStatement ? getGenerateKey(parameters, (InsertStatement) sqlStatement) : Optional.<GeneratedKey>absent();
  SQLRouteResult result = new SQLRouteResult(sqlStatement, generatedKey.orNull());
  ShardingConditions shardingConditions = OptimizeEngineFactory.newInstance(shardingRule, sqlStatement, parameters, generatedKey.orNull()).optimize();
  if (generatedKey.isPresent()) {
    setGeneratedKeys(result, generatedKey.get());
  }
  if (sqlStatement instanceof SelectStatement && isNeedMergeShardingValues((SelectStatement) sqlStatement)) {
    checkSubqueryShardingValues(sqlStatement, sqlStatement.getConditions(), shardingConditions);
    mergeShardingValues(shardingConditions);
  }
  RoutingResult routingResult = RoutingEngineFactory.newInstance(shardingRule, shardingMetaData.getDataSource(), sqlStatement, shardingConditions).route();
  boolean isSingleRouting = routingResult.isSingleRouting();
  SQLRewriteEngine rewriteEngine = new SQLRewriteEngine(shardingRule, logicSQL, databaseType, sqlStatement, shardingConditions, parameters);
  if (sqlStatement instanceof SelectStatement && null != ((SelectStatement) sqlStatement).getLimit()) {
    processLimit(parameters, (SelectStatement) sqlStatement, isSingleRouting);
  }
  SQLBuilder sqlBuilder = rewriteEngine.rewrite(isSingleRouting);
  for (TableUnit each : routingResult.getTableUnits().getTableUnits()) {
    result.getRouteUnits().add(new RouteUnit(each.getDataSourceName(), rewriteEngine.generateSQL(each, sqlBuilder, shardingMetaData.getDataSource())));
  }
  if (showSQL) {
    SQLLogger.logSQL(logicSQL, sqlStatement, result.getRouteUnits());
  }
  return result;
}

private ShardingMetaData createShardingMetaData() {
  return new ShardingMetaData(getDataSourceURLs(getDataSources()), new ShardingRule(new ShardingRuleConfiguration(), getDataSources().keySet()), 
      DatabaseType.PostgreSQL, BackendExecutorContext.getInstance().getExecuteEngine(), new ProxyTableMetaDataConnectionManager(getBackendDataSource()),
      GlobalRegistry.getInstance().getShardingProperties().<Integer>getValue(ShardingPropertiesConstant.MAX_CONNECTIONS_SIZE_PER_QUERY), 
      GlobalRegistry.getInstance().getShardingProperties().<Boolean>getValue(ShardingPropertiesConstant.CHECK_TABLE_METADATA_ENABLED));
}

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

  @Override
  protected SimpleChannelPool newPool(final String dataSourceName) {
    DataSourceMetaData dataSourceMetaData = logicSchema.getMetaData().getDataSource().getActualDataSourceMetaData(dataSourceName);
    return new FixedChannelPool(
        bootstrap.remoteAddress(dataSourceMetaData.getHostName(), dataSourceMetaData.getPort()), 
        new BackendNettyClientChannelPoolHandler(dataSourceName, logicSchema.getName()), maxConnections);
  }
};

private ShardingMetaData createShardingMetaData() {
  return new ShardingMetaData(getDataSourceURLs(getDataSources()), new ShardingRule(new ShardingRuleConfiguration(), getDataSources().keySet()), 
      DatabaseType.MySQL, BackendExecutorContext.getInstance().getExecuteEngine(), new ProxyTableMetaDataConnectionManager(getBackendDataSource()), 
      GlobalRegistry.getInstance().getShardingProperties().<Integer>getValue(ShardingPropertiesConstant.MAX_CONNECTIONS_SIZE_PER_QUERY), 
      GlobalRegistry.getInstance().getShardingProperties().<Boolean>getValue(ShardingPropertiesConstant.CHECK_TABLE_METADATA_ENABLED));
}

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

  @Override
  protected SimpleChannelPool newPool(final String dataSourceName) {
    DataSourceMetaData dataSourceMetaData = logicSchema.getMetaData().getDataSource().getActualDataSourceMetaData(dataSourceName);
    return new FixedChannelPool(
        bootstrap.remoteAddress(dataSourceMetaData.getHostName(), dataSourceMetaData.getPort()), 
        new BackendNettyClientChannelPoolHandler(dataSourceName, logicSchema.getName()), maxConnections);
  }
};

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