if (supportsRemove()) {
      assertNull(table.remove("cat", 1));
      assertNull(table.remove("bar", 3));
      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));

    #   [true]
    #     Add schema to table SQL name. (The table name on query is SCHEMA.TABLE)
    #
    #; isAvailableAddingSchemaToTableSqlName = false
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o isAvailableAddingCatalogToTableSqlName: (NotRequired - Default false)
    #   [true]
    #     Add catalog to table SQL name. (The table name on query is CATALOG.SCHEMA.TABLE)
    #

  }

  @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');

      ]),
  },

  tables: {
    local table = g.panel.table,
    local override = table.fieldOverride,
    base(title, targets, desc=''):
      table.new(title)
      + table.queryOptions.withTargets(targets)
      + table.queryOptions.withInterval('5s')
      + if std.length(desc) > 0 then
        table.panelOptions.withDescription(desc)
      else {},

The `Hero` class is very similar to a Pydantic model (in fact, underneath, it actually *is a Pydantic model*).

There are a few differences:

* `table=True` tells SQLModel that this is a *table model*, it should represent a **table** in the SQL database, it's not just a *data model* (as would be any other regular Pydantic class).

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

		ID   uint
		Name string
		Age  int
	}

	var res result
	DB.Table("users").Select("id, name, age").Where("id = ?", user3.ID).Scan(&res)
	if res.ID != user3.ID || res.Name != user3.Name || res.Age != int(user3.Age) {
		t.Fatalf("Scan into struct should work, got %#v, should %#v", res, user3)
	}

	var resPointer *result
	if err := DB.Table("users").Select("id, name, age").Where("id = ?", user3.ID).Scan(&resPointer).Error; err != nil {

    table.put("cat", 1, 'b');
    table.clear();
    populate(table, data);
    return table;
  }

  public void testCreateExplicitComparators() {
    table = TreeBasedTable.create(Collections.reverseOrder(), Ordering.usingToString());
    table.put("foo", 3, 'a');
    table.put("foo", 12, 'b');
    table.put("bar", 5, 'c');
    table.put("cat", 8, 'd');

        titleabbrev.appendChild(document.createTextNode(" plugin"));

        Element table = document.createElement("table");
        section.appendChild(table);

        title = document.createElement("title");
        table.appendChild(title);
        title.appendChild(document.createTextNode("Methods - "));
        literal = document.createElement("literal");

  }

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