}

  @Override
  Table<Character, String, Integer> makeTable() {
    Table<Character, String, Integer> table = HashBasedTable.create();
    return transformValues(table, TableCollectionTest.DIVIDE_BY_2);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<Character, String, Integer> table = HashBasedTable.create();
    table.put('a', "one", 2);
    table.put('a', "two", 4);

  }

  @Override
  Table<Integer, String, Character> makeTable() {
    RowSortedTable<Integer, String, Character> original = TreeBasedTable.create();
    return unmodifiableRowSortedTable(original);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    RowSortedTable<Integer, String, Character> table = TreeBasedTable.create();
    table.put(1, "foo", 'a');
    table.put(1, "bar", 'b');

  }

  @Override
  Table<String, Integer, Character> makeTable() {
    Table<String, Integer, Character> original = HashBasedTable.create();
    return unmodifiableTable(original);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<String, Integer, Character> table = HashBasedTable.create();
    table.put("foo", 1, 'a');
    table.put("bar", 1, 'b');

  }

  @Override
  Table<String, Integer, Character> makeTable() {
    Table<String, Integer, String> original = HashBasedTable.create();
    return transformValues(original, TableCollectionTest.FIRST_CHARACTER);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<String, Integer, String> table = HashBasedTable.create();
    table.put("foo", 1, "apple");

  }

  @Override
  Table<Character, String, Integer> makeTable() {
    RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
    return unmodifiableRowSortedTable(table);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
    table.put('a', "one", 1);
    table.put('a', "two", 2);

  }

  @Override
  Table<Integer, String, Character> makeTable() {
    Table<Integer, String, Character> original = HashBasedTable.create();
    return unmodifiableTable(original);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<Integer, String, Character> table = HashBasedTable.create();
    table.put(1, "foo", 'a');
    table.put(1, "bar", 'b');

  }

  @Override
  Table<String, Character, Integer> makeTable() {
    Table<String, Character, Integer> table = HashBasedTable.create();
    return unmodifiableTable(table);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<String, Character, Integer> table = HashBasedTable.create();
    table.put("one", 'a', 1);
    table.put("two", 'a', 2);
    table.put("three", 'a', 3);

		if tables := strings.Split(stmt.Schema.Table, "."); len(tables) == 2 {
			stmt.TableExpr = &clause.Expr{SQL: stmt.Quote(stmt.Schema.Table)}
			stmt.Table = tables[1]
			return
		}

		stmt.Table = stmt.Schema.Table
	}
	return err
}

func (stmt *Statement) clone() *Statement {
	newStmt := &Statement{

)

// Namer namer interface
type Namer interface {
	TableName(table string) string
	SchemaName(table string) string
	ColumnName(table, column string) string
	JoinTableName(joinTable string) string
	RelationshipFKName(Relationship) string
	CheckerName(table, column string) string
	IndexName(table, column string) string
	UniqueName(table, column string) string
}

// Replacer replacer interface like strings.Replacer

 *       as that of its keys. This is sometimes called an "invertible map," since the restriction on
 *       values enables it to support an {@linkplain BiMap#inverse inverse view} -- which is another
 *       instance of {@code BiMap}.
 *   <dt>{@link Table}
 *   <dd>A new type, which is similar to {@link java.util.Map}, but which indexes its values by an
 *       ordered pair of keys, a row key and column key.