Function TEST

cpp/src/arrow/acero/hash_join_node_test.cc:934–983

}

TEST(HashJoin, Suffix) {
  BatchesWithSchema input_left;
  input_left.batches = {ExecBatchFromJSON({int32(), int32(), int32()}, R"([
                   [1, 4, 7],
                   [2, 5, 8],
                   [3, 6, 9]
                 ])")};
  input_left.schema = schema(
      {field("lkey", int32()), field("shared", int32()), field("ldistinct", int32())});

  BatchesWithSchema input_right;
  input_right.batches = {ExecBatchFromJSON({int32(), int32(), int32()}, R"([
                   [1, 10, 13],
                   [2, 11, 14],
                   [3, 12, 15]
                 ])")};
  input_right.schema = schema(
      {field("rkey", int32()), field("shared", int32()), field("rdistinct", int32())});

  BatchesWithSchema expected;
  expected.batches = {
      ExecBatchFromJSON({int32(), int32(), int32(), int32(), int32(), int32()}, R"([
    [1, 4, 7, 1, 10, 13],
    [2, 5, 8, 2, 11, 14],
    [3, 6, 9, 3, 12, 15]
  ])")};

  expected.schema = schema({field("lkey", int32()), field("shared_l", int32()),
                            field("ldistinct", int32()), field("rkey", int32()),
                            field("shared_r", int32()), field("rdistinct", int32())});

  AsyncGenerator<std::optional<ExecBatch>> sink_gen;

  Declaration left{"source",
                   SourceNodeOptions{input_left.schema, input_left.gen(/*parallel=*/false,
                                                                       /*slow=*/false)}};
  Declaration right{
      "source", SourceNodeOptions{input_right.schema, input_right.gen(/*parallel=*/false,
                                                                      /*slow=*/false)}};
  HashJoinNodeOptions join_opts{JoinType::INNER,
                                /*left_keys=*/{"lkey"},
                                /*right_keys=*/{"rkey"}, literal(true), "_l", "_r"};

  Declaration join{"hashjoin", {std::move(left), std::move(right)}, join_opts};

  ASSERT_OK_AND_ASSIGN(auto actual, DeclarationToExecBatches(std::move(join)));

  AssertExecBatchesEqualIgnoringOrder(expected.schema, expected.batches, actual.batches);
  AssertSchemaEqual(expected.schema, actual.schema);
}

TEST(HashJoin, Random) {
  Random64Bit rng(42);