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 {

  }

  /**
   * Returns an immutable copy of the provided table.
   *
   * <p>The {@link Table#cellSet()} iteration order of the provided table determines the iteration
   * ordering of all views in the returned table. Note that some views of the original table and the
   * copied table may have different iteration orders. For more control over the ordering, create a

		Result        string
	}{
		{
			SQL:           "create table users (name, age, height, actived, bytes, create_at, update_at, deleted_at, email, role, pass) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
			NumericRegexp: nil,
			Vars:          []interface{}{"jinzhu", 1, 999.99, true, []byte("12345"), tt, &tt, nil, "w@g.\"com", myrole, pwd},

  }

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

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

  }

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

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

    assertEquals(1, binarySearch(0, 6) { index -> 3.compareTo(table[index]) })
    assertEquals(2, binarySearch(0, 6) { index -> 5.compareTo(table[index]) })
    assertEquals(3, binarySearch(0, 6) { index -> 7.compareTo(table[index]) })
    assertEquals(4, binarySearch(0, 6) { index -> 9.compareTo(table[index]) })
    assertEquals(5, binarySearch(0, 6) { index -> 11.compareTo(table[index]) })

  public void testToTable() {
    Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector =
        TableCollectors.toTable(
            Cell::getRowKey, Cell::getColumnKey, Cell::getValue, HashBasedTable::create);
    BiPredicate<Table<String, String, Integer>, Table<String, String, Integer>> equivalence =
        pairwiseOnResultOf(Table::cellSet);
    CollectorTester.of(collector, equivalence)
        .expectCollects(

    AtomicReferenceArray<ReferenceEntry<Object, Object>> table = segment.table;
    int index = hash & (table.length() - 1);

    // already loading
    DummyEntry<Object, Object> entry = DummyEntry.create(key, hash, null);
    DummyValueReference<Object, Object> valueRef = DummyValueReference.create(null);
    valueRef.setLoading(true);
    entry.setValueReference(valueRef);
    table.set(index, entry);

        };
    Map<String, Map<Integer, Character>> backingMap = new LinkedHashMap<>();
    Table<String, Integer, Character> table = newCustomTable(backingMap, factory);
    populate(table, data);
    return table;
  }

  public void testRowKeySetOrdering() {
    table = create("foo", 3, 'a', "bar", 1, 'b', "foo", 2, 'c');
    assertThat(table.rowKeySet()).containsExactly("foo", "bar").inOrder();
  }

  public void testRowOrdering() {

    TreeBasedTable<String, Integer, Character> table = TreeBasedTable.create();
    table.put("a", 1, 'a');
    return table;
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    TreeBasedTable<String, Integer, Character> table = makeTable();
    populateTable(table);
    return table.rowMap().tailMap("b");
  }

  @Override