Method BasicTest

be/src/exec/hash-table-test.cc:332–399

This test inserts the build rows [0->5) to hash table. It validates that they are all there using a full table scan. It also validates that Find() is correct testing for probe rows that are both there and not. The hash table is resized a few times and the scans/finds are tested again.

  // testing for probe rows that are both there and not.
  // The hash table is resized a few times and the scans/finds are tested again.
  void BasicTest(bool quadratic, int initial_num_buckets) {
    TupleRow* build_rows[5];
    TupleRow* scan_rows[5] = {0};
    for (int i = 0; i < 5; ++i) build_rows[i] = CreateTupleRow(i);

    ProbeTestData probe_rows[10];
    for (int i = 0; i < 10; ++i) {
      probe_rows[i].probe_row = CreateTupleRow(i);
      if (i < 5) probe_rows[i].expected_build_rows.push_back(build_rows[i]);
    }

    // Create the hash table and insert the build rows
    HashTable* hash_table;
    ASSERT_TRUE(CreateHashTable(quadratic, initial_num_buckets, &hash_table));
    scoped_ptr<HashTableCtx> ht_ctx;
    Status status = HashTableCtx::Create(&pool_, runtime_state_, build_exprs_,
        probe_exprs_, false /* !stores_nulls_ */,
        vector<bool>(build_exprs_.size(), false), 1, 0, 1, &mem_pool_, &mem_pool_,
        &mem_pool_, &ht_ctx);
    EXPECT_OK(status);
    EXPECT_OK(ht_ctx->Open(runtime_state_));
    bool success;
    EXPECT_OK(hash_table->CheckAndResize(5, ht_ctx.get(), &success));
    ASSERT_TRUE(success);
    for (int i = 0; i < 5; ++i) {
      if (!ht_ctx->EvalAndHashBuild(build_rows[i])) continue;
      BufferedTupleStream::FlatRowPtr dummy_flat_row = nullptr;
      EXPECT_TRUE(hash_table->stores_tuples_);
      bool inserted =
          hash_table->Insert(ht_ctx.get(), dummy_flat_row, build_rows[i], &status);
      EXPECT_TRUE(inserted);
      ASSERT_OK(status);
    }
    EXPECT_EQ(hash_table->size(), 5);

    // Do a full table scan and validate returned pointers
    FullScan(hash_table, ht_ctx.get(), 0, 5, true, scan_rows, build_rows);
    ProbeTest(hash_table, ht_ctx.get(), probe_rows, 10, false);

    // Double the size of the hash table and scan again.
    EXPECT_OK(ResizeTable(hash_table, 2048, ht_ctx.get(), &success));
    EXPECT_TRUE(success);
    EXPECT_EQ(hash_table->num_buckets(), 2048);
    EXPECT_EQ(hash_table->size(), 5);
    memset(scan_rows, 0, sizeof(scan_rows));
    FullScan(hash_table, ht_ctx.get(), 0, 5, true, scan_rows, build_rows);
    ProbeTest(hash_table, ht_ctx.get(), probe_rows, 10, false);

    // Try to shrink and scan again.
    EXPECT_OK(ResizeTable(hash_table, 64, ht_ctx.get(), &success));
    EXPECT_TRUE(success);
    EXPECT_EQ(hash_table->num_buckets(), 64);
    EXPECT_EQ(hash_table->size(), 5);
    memset(scan_rows, 0, sizeof(scan_rows));
    FullScan(hash_table, ht_ctx.get(), 0, 5, true, scan_rows, build_rows);
    ProbeTest(hash_table, ht_ctx.get(), probe_rows, 10, false);

    // Resize to 8, which is the smallest value to fit the number of filled buckets.