assertTrue(table.contains("bar", 1));
    assertTrue(table.contains("foo", 3));
    assertFalse(table.contains("foo", 2));
    assertFalse(table.contains("bar", 3));
    assertFalse(table.contains("cat", 1));
    assertFalse(table.contains("foo", null));
    assertFalse(table.contains(null, 1));
    assertFalse(table.contains(null, null));
  }

  public void testContainsRow() {

    if (supportsRemove()) {
      assertThat(table.remove("cat", 1)).isNull();
      assertThat(table.remove("bar", 3)).isNull();
      assertEquals(3, table.size());
      assertEquals((Character) 'c', table.remove("foo", 3));
      assertEquals(2, table.size());
      assertEquals((Character) 'a', table.get("foo", 1));
      assertEquals((Character) 'b', table.get("bar", 1));

  private static void populateForRowKeySet(
      Table<String, Integer, Character> table, String[] elements) {
    for (String row : elements) {
      table.put(row, 1, 'a');
      table.put(row, 2, 'b');
    }
  }

  private static void populateForColumnKeySet(
      Table<Integer, String, Character> table, String[] elements) {
    for (String column : elements) {
      table.put(1, column, 'a');
      table.put(2, column, 'b');

		Result: "`table`.`col` AS `alias`",
	}, {
		SQL:    "?",
		Vars:   []interface{}{clause.Column{Table: "table", Name: "col", Alias: "alias", Raw: true}},
		Result: "table.col AS alias",
	}, {
		SQL:    "?",
		Vars:   []interface{}{clause.Table{Name: "table", Alias: "alias"}},
		Result: "`table` `alias`",
	}, {
		SQL:    "?",

    if (supportsRemove()) {
      assertThat(table.remove("cat", 1)).isNull();
      assertThat(table.remove("bar", 3)).isNull();
      assertEquals(3, table.size());
      assertEquals((Character) 'c', table.remove("foo", 3));
      assertEquals(2, table.size());
      assertEquals((Character) 'a', table.get("foo", 1));
      assertEquals((Character) 'b', table.get("bar", 1));

			join: clause.Join{
				// Invalid
				Type:  clause.LeftJoin,
				Table: clause.Table{Name: "user"},
				ON: clause.Where{
					Exprs: []clause.Expression{clause.Eq{clause.Column{Table: "user_info", Name: "user_id"}, clause.PrimaryColumn}},
				},
				// Valid
				Expression: clause.Join{
					Type:  clause.InnerJoin,
					Table: clause.Table{Name: "user"},
					Using: []string{"id"},
				},
			},

			Op:         replication.AddOption,
			RuleStatus: "enable",
			DestBucket: targetARN,
			// Replicate everything!
			ReplicateDeletes:        "enable",
			ReplicateDeleteMarkers:  "enable",
			ReplicaSync:             "enable",
			ExistingObjectReplicate: "enable",
		}

		switch {
		case hasRule:
			if ruleARN != opts.DestBucket {
				// remove stale replication rule and replace rule with correct target ARN

)

// 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

    table.put("c", "b", "a");
    table.put("b", "b", "x");
    table.put("b", "c", "y");
    table.put("b", "x", "n");
    table.put("a", "a", "d");
    table.row("b").subMap("c", "x").clear();
    assertEquals(table.row("b"), ImmutableMap.of("b", "x", "x", "n"));
    table.row("b").subMap("b", "y").clear();
    assertEquals(table.row("b"), ImmutableMap.of());
    assertFalse(table.backingMap.containsKey("b"));
  }

		},
		{
			[]clause.Interface{
				clause.Select{}, clause.From{
					Tables: []clause.Table{{Name: "users"}},
					Joins: []clause.Join{
						{
							Type:  clause.RightJoin,
							Table: clause.Table{Name: "profiles"},
							ON: clause.Where{
								[]clause.Expression{clause.Eq{clause.Column{Table: "profiles", Name: "email"}, clause.Column{Table: clause.CurrentTable, Name: "email"}}},
							},
						},
					},