How to use

ShardingTableMetaData

in

org.apache.shardingsphere.core.metadata.table

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 boolean isSameSelectItem(final SelectStatement selectStatement, final StarSelectItem starSelectItem, final OrderItem orderItem, final ShardingTableMetaData shardingTableMetaData) {
  Preconditions.checkState(starSelectItem.getOwner().isPresent());
  Preconditions.checkState(orderItem.getName().isPresent());
  Optional<Table> table = selectStatement.getTables().find(starSelectItem.getOwner().get());
  return table.isPresent() && shardingTableMetaData.containsColumn(table.get().getName(), orderItem.getName().get());
}

/**
 * Judge contains column from table meta data or not.
 * 
 * @param tableName table name
 * @param column column
 * @return contains column from table meta data or not
 */
public boolean containsColumn(final String tableName, final String column) {
  return containsTable(tableName) && tables.get(tableName).getColumns().keySet().contains(column.toLowerCase());
}

/**
 * Find column definition from meta data.
 *
 * @param columnName column name
 * @param shardingTableMetaData sharding table meta data
 * @return column definition
 */
public Optional<ColumnDefinitionSegment> findColumnDefinitionFromMetaData(final String columnName, final ShardingTableMetaData shardingTableMetaData) {
  if (!shardingTableMetaData.containsTable(getTables().getSingleTableName())) {
    return Optional.absent();
  }
  for (ColumnMetaData each : shardingTableMetaData.get(getTables().getSingleTableName()).getColumns().values()) {
    if (columnName.equalsIgnoreCase(each.getColumnName())) {
      return Optional.of(new ColumnDefinitionSegment(columnName, each.getDataType(), each.isPrimaryKey()));
    }
  }
  return Optional.absent();
}

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

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

  private Collection<Column> parseWithoutColumn(
      final InsertStatement insertStatement, final ShardingTableMetaData shardingTableMetaData, final String tableName, final Optional<Column> generateKeyColumn) {
    int count = 0;
    int beginPosition = lexerEngine.getCurrentToken().getEndPosition() - lexerEngine.getCurrentToken().getLiterals().length() - 1;
    insertStatement.addSQLToken(new InsertColumnToken(beginPosition, "("));
    ItemsToken columnsToken = new ItemsToken(beginPosition);
    columnsToken.setFirstOfItemsSpecial(true);
    Collection<Column> result = new LinkedList<>();
    if (shardingTableMetaData.containsTable(tableName)) {
      for (String each : shardingTableMetaData.getAllColumnNames(tableName)) {
        result.add(new Column(each, tableName));
        if (generateKeyColumn.isPresent() && generateKeyColumn.get().getName().equalsIgnoreCase(each)) {
          insertStatement.setGenerateKeyColumnIndex(count);
        }
        columnsToken.getItems().add(each);
        count++;
      }
    }
    insertStatement.addSQLToken(columnsToken);
    insertStatement.addSQLToken(new InsertColumnToken(beginPosition, ")"));
    insertStatement.setColumnsListLastIndex(beginPosition);
    return result;
  }
}

private void fillColumnTableMap(final SQLStatement sqlStatement, final ShardingTableMetaData shardingTableMetaData,
                final Map<String, String> columnNameToTable, final Map<String, Integer> columnNameCount) {
  if (null == shardingTableMetaData) {
    return;
  }
  for (String each : sqlStatement.getTables().getTableNames()) {
    Collection<String> tableColumns = shardingTableMetaData.getAllColumnNames(each);
    for (String columnName : tableColumns) {
      columnNameToTable.put(columnName, each);
      Integer count = columnNameCount.get(columnName);
      if (null == count) {
        count = 1;
      } else {
        count++;
      }
      columnNameCount.put(columnName, count);
    }
  }
}

  public ShardingMetaData(final Map<String, String> dataSourceURLs, final ShardingRule shardingRule, final DatabaseType databaseType, final ShardingExecuteEngine executeEngine, 
              final TableMetaDataConnectionManager connectionManager, final int maxConnectionsSizePerQuery, final boolean isCheckingMetaData) {
    dataSource = new ShardingDataSourceMetaData(dataSourceURLs, shardingRule, databaseType);
    table = new ShardingTableMetaData(new TableMetaDataInitializer(dataSource, executeEngine, connectionManager, maxConnectionsSizePerQuery, isCheckingMetaData).load(shardingRule));
  }
}

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

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

private void createFromMeta(final InsertStatement insertStatement, final InsertSegment sqlSegment, final ShardingRule shardingRule, final ShardingTableMetaData shardingTableMetaData) {
  int count = 0;
  String tableName = insertStatement.getTables().getSingleTableName();
  int startIndex = sqlSegment.getColumnClauseStartIndex();
  insertStatement.addSQLToken(new InsertColumnToken(startIndex, "("));
  ItemsToken columnsToken = new ItemsToken(startIndex);
  columnsToken.setFirstOfItemsSpecial(true);
  if (shardingTableMetaData.containsTable(tableName)) {
    Optional<Column> generateKeyColumn = shardingRule.findGenerateKeyColumn(insertStatement.getTables().getSingleTableName());
    for (String each : shardingTableMetaData.getAllColumnNames(tableName)) {
      if (generateKeyColumn.isPresent() && generateKeyColumn.get().getName().equalsIgnoreCase(each)) {
        insertStatement.setGenerateKeyColumnIndex(count);
      }
      Column column = new Column(each, tableName);
      insertStatement.getColumns().add(column);
      columnsToken.getItems().add(each);
      count++;
    }
  }
  insertStatement.addSQLToken(columnsToken);
  insertStatement.addSQLToken(new InsertColumnToken(startIndex, ")"));
  insertStatement.setColumnsListLastIndex(startIndex);
}

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 DropTableStatement dropTableStatement) {
    for (String each : dropTableStatement.getTables().getTableNames()) {
      getMetaData().getTable().remove(each);
    }
  }
}

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

private boolean isSameSelectItem(final SelectStatement selectStatement, final StarSelectItem starSelectItem, final OrderItem orderItem) {
  Preconditions.checkState(starSelectItem.getOwner().isPresent());
  Preconditions.checkState(orderItem.getName().isPresent());
  Optional<Table> table = selectStatement.getTables().find(starSelectItem.getOwner().get());
  return table.isPresent() && shardingTableMetaData.containsColumn(table.get().getName(), orderItem.getName().get());
}

private Iterator<MemoryQueryResultRow> init(final List<QueryResult> queryResults) throws SQLException {
  List<MemoryQueryResultRow> result = new LinkedList<>();
  for (QueryResult each : queryResults) {
    while (each.next()) {
      MemoryQueryResultRow memoryResultSetRow = new MemoryQueryResultRow(each);
      String actualTableName = memoryResultSetRow.getCell(1).toString();
      Optional<TableRule> tableRule = shardingRule.findTableRuleByActualTable(actualTableName);
      if (!tableRule.isPresent()) {
        if (shardingRule.getTableRules().isEmpty() || shardingTableMetaData.containsTable(actualTableName) && tableNames.add(actualTableName)) {
          result.add(memoryResultSetRow);
        }
      } else if (tableNames.add(tableRule.get().getLogicTable())) {
        memoryResultSetRow.setCell(1, tableRule.get().getLogicTable());
        setCellValue(memoryResultSetRow, tableRule.get().getLogicTable(), actualTableName);
        result.add(memoryResultSetRow);
      }
    }
  }
  if (!result.isEmpty()) {
    setCurrentResultSetRow(result.get(0));
  }
  return result.iterator();
}

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