oceanbase/unittest/sql/engine/set/test_hash_set_dump.cpp

/**
 * Copyright (c) 2021 OceanBase
 * OceanBase CE is licensed under Mulan PubL v2.
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
 * You may obtain a copy of Mulan PubL v2 at:
 *          http://license.coscl.org.cn/MulanPubL-2.0
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PubL v2 for more details.
 */

#define USING_LOG_PREFIX SQL

#include <gtest/gtest.h>

#define private public
#define protected public

#include "sql/engine/set/ob_hash_union.h"
#include "sql/engine/set/ob_hash_intersect.h"
#include "sql/engine/set/ob_hash_except.h"
#include "sql/engine/set/ob_merge_union.h"
#include "sql/engine/set/ob_merge_intersect.h"
#include "sql/engine/set/ob_merge_except.h"
#include "share/system_variable/ob_system_variable.h"
#include "storage/blocksstable/ob_data_file_prepare.h"
#include "sql/engine/table/ob_fake_table.h"
#include "set_data_generator.h"
#include "sql/ob_sql_init.h"
#include "share/ob_cluster_version.h"
#include "observer/omt/ob_tenant_config_mgr.h"
#include "observer/ob_server.h"
namespace oceanbase {
namespace sql {
using namespace common;
using namespace share;
using namespace omt;

class MockSqlExpression : public ObSqlExpression {
public:
  MockSqlExpression(ObIAllocator& alloc) : ObSqlExpression(alloc)
  {
    set_item_count(10);
  }
};

#define TEST_SET_DUMP_GET_HASH_AREA_SIZE() (get_hash_area_size())
#define TEST_SET_DUMP_SET_HASH_AREA_SIZE(size) (set_hash_area_size(size))

class ObHashSetDumpTest : public blocksstable::TestDataFilePrepare, public ::testing::WithParamInterface<ObJoinType> {
public:
  enum TestAlgo { UNION = 0, INTERSECT, EXCEPT };

protected:
  struct SetPlan {
    explicit SetPlan(ObIAllocator& alloc) : set_op_(nullptr), left_(alloc), right_(alloc), expr_(alloc)
    {}

    int setup_plan(ObSetOperator* set_op);

    ObSQLSessionInfo session_;
    ObPhysicalPlan plan_;
    ObExecContext exec_ctx_;
    ObSetOperator* set_op_;
    SetDataGenerator left_;
    SetDataGenerator right_;
    MockSqlExpression expr_;
  };

public:
  ObHashSetDumpTest()
      : blocksstable::TestDataFilePrepare("TestDiskIR", 8 << 20, 5000),
        hash_union_(alloc_),
        merge_union_(alloc_),
        hash_intersect_(alloc_),
        merge_intersect_(alloc_),
        hash_except_(alloc_),
        merge_except_(alloc_),
        hash_set_op_(nullptr),
        merge_set_op_(nullptr),
        hash_plan_(alloc_),
        merge_plan_(alloc_)
  {}

  int init_tenant_mgr();
  virtual void SetUp() override
  {
    ASSERT_EQ(OB_SUCCESS, init_tenant_mgr());
    blocksstable::TestDataFilePrepare::SetUp();
    ASSERT_EQ(OB_SUCCESS, blocksstable::ObTmpFileManager::get_instance().init());
    ASSERT_EQ(OB_SUCCESS, blocksstable::ObTmpFileManager::get_instance().start());
    CHUNK_MGR.set_limit(128L * 1024L * 1024L * 1024L);
    GCONF.enable_sql_operator_dump.set_value("True");
    uint64_t cluster_version = CLUSTER_VERSION_3000;
    common::ObClusterVersion::get_instance().update_cluster_version(cluster_version);
    EXPECT_EQ(cluster_version, common::ObClusterVersion::get_instance().get_cluster_version());
    LOG_INFO(
        "set cluster version", K(cluster_version), K(common::ObClusterVersion::get_instance().get_cluster_version()));
    OBSERVER.init_schema();
    OBSERVER.init_tz_info_mgr();
  }
  virtual void TearDown() override
  {
    blocksstable::ObTmpFileManager::get_instance().destroy();
    blocksstable::TestDataFilePrepare::TearDown();
    destroy_tenant_mgr();
  }

  void destroy_tenant_mgr()
  {
    ObTenantManager::get_instance().destroy();
  }

  int64_t get_hash_area_size()
  {
    int64_t hash_area_size = 0;
    int ret = OB_SUCCESS;
    ret = ObSqlWorkareaUtil::get_workarea_size(HASH_WORK_AREA, OB_SYS_TENANT_ID, hash_area_size);
    if (OB_FAIL(ret)) {
      LOG_WARN("failed to get hash area size", K(ret), K(hash_area_size));
    }
    return hash_area_size;
  }

  void set_hash_area_size(int64_t size)
  {
    int ret = OB_SUCCESS;
    int64_t tenant_id = OB_SYS_TENANT_ID;
    ObTenantConfigGuard tenant_config(TENANT_CONF(tenant_id));
    if (tenant_config.is_valid()) {
      tenant_config->_hash_area_size = size;
    } else {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("unexpected status: config is invalid", K(tenant_id));
    }
    // ASSERT_EQ(OB_SUCCESS, ret);
  }

  void setup_plan(SetPlan& plan, bool hash_algo, ObHashSetDumpTest::TestAlgo algo);
  void setup_test(TestAlgo algo, int32_t string_size, int64_t left_row_count, bool left_reverse,
      SetDataGenerator::IdxCntFunc left_func, int64_t right_row_count, bool right_reverse,
      SetDataGenerator::IdxCntFunc right_func);

  // iterate hash join result and verify result with merge join.
  void run_test(int64_t print_row_cnt = 0);

protected:
  ObArenaAllocator alloc_;

  ObHashUnion hash_union_;
  ObMergeUnion merge_union_;

  ObHashIntersect hash_intersect_;
  ObMergeIntersect merge_intersect_;

  ObHashExcept hash_except_;
  ObMergeExcept merge_except_;

  ObSetOperator* hash_set_op_;
  ObSetOperator* merge_set_op_;

  SetPlan hash_plan_;
  SetPlan merge_plan_;
};

int ObHashSetDumpTest::SetPlan::setup_plan(ObSetOperator* set_op)
{
  int ret = OB_SUCCESS;
  left_.set_id(0);
  right_.set_id(1);
  set_op_ = set_op;
  set_op_->set_id(2);

  set_op_->set_column_count(SetDataGenerator::CELL_CNT * 2);

  left_.set_phy_plan(&plan_);
  right_.set_phy_plan(&plan_);
  set_op_->set_phy_plan(&plan_);
  set_op_->create_child_array(2);
  if (OB_FAIL(set_op_->set_child(0, right_))) {
  } else if (OB_FAIL(set_op_->set_child(1, left_))) {
  }

  set_op_->set_distinct(true);

  // setup context
  ObString tenant_name("test");
  if (OB_FAIL(ret)) {
  } else if (OB_FAIL(session_.test_init(0, 0, 0, NULL))) {
  } else if (OB_FAIL(ObPreProcessSysVars::init_sys_var())) {
  } else if (OB_FAIL(session_.load_default_sys_variable(false, true))) {
  } else if (OB_FAIL(session_.init_tenant(tenant_name, OB_SYS_TENANT_ID))) {
  } else if (FALSE_IT(exec_ctx_.set_my_session(&session_))) {
  } else if (OB_FAIL(exec_ctx_.init_phy_op(3))) {
  } else if (OB_FAIL(exec_ctx_.create_physical_plan_ctx())) {
  }
  return ret;
}

void ObHashSetDumpTest::setup_plan(SetPlan& plan, bool hash_algo, ObHashSetDumpTest::TestAlgo algo)
{
  int ret = OB_SUCCESS;
  ObMergeSetOperator* merge_op = nullptr;
  ObHashSetOperator* hash_op = nullptr;
  switch (algo) {
    case UNION:
      if (hash_algo) {
        ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&hash_union_));
        hash_set_op_ = &hash_union_;
        hash_op = &hash_union_;
      } else {
        ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&merge_union_));
        merge_op = &merge_union_;
        merge_set_op_ = &merge_union_;
      }
      break;
    case INTERSECT:
      if (hash_algo) {
        ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&hash_intersect_));
        hash_set_op_ = &hash_intersect_;
        hash_op = &hash_intersect_;
      } else {
        ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&merge_intersect_));
        merge_op = &merge_intersect_;
        merge_set_op_ = &merge_intersect_;
      }
      break;
    case EXCEPT:
      if (hash_algo) {
        ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&hash_except_));
        hash_set_op_ = &hash_except_;
        hash_op = &hash_except_;
      } else {
        ASSERT_EQ(OB_SUCCESS, plan.setup_plan(&merge_except_));
        merge_op = &merge_except_;
        merge_set_op_ = &merge_except_;
      }
      break;
    default:
      break;
  }
  if (nullptr != merge_op) {
    ASSERT_EQ(OB_SUCCESS, merge_op->init(SetDataGenerator::CELL_CNT));
    ObOrderDirection direction = NULLS_FIRST_ASC;
    for (int64_t i = 0; i < SetDataGenerator::CELL_CNT; ++i) {
      ASSERT_EQ(OB_SUCCESS, merge_op->add_set_direction(direction));
    }
    for (int64_t i = 0; i < SetDataGenerator::CELL_CNT && OB_SUCC(ret); ++i) {
      if (OB_FAIL(merge_op->add_collation_type(ObCollationType::CS_TYPE_UTF8MB4_BIN))) {
        LOG_WARN("failed to add collation type", K(ret));
      }
    }
  }
  if (nullptr != hash_op) {
    ASSERT_EQ(OB_SUCCESS, hash_op->init(SetDataGenerator::CELL_CNT));
    for (int64_t i = 0; i < SetDataGenerator::CELL_CNT && OB_SUCC(ret); ++i) {
      if (OB_FAIL(hash_op->add_collation_type(ObCollationType::CS_TYPE_UTF8MB4_BIN))) {
        LOG_WARN("failed to add collation type", K(ret));
      }
    }
  }
}

void ObHashSetDumpTest::setup_test(TestAlgo algo, int32_t string_size, int64_t left_row_count, bool left_reverse,
    SetDataGenerator::IdxCntFunc left_func, int64_t right_row_count, bool right_reverse,
    SetDataGenerator::IdxCntFunc right_func)
{
  SetPlan* plans[] = {&hash_plan_, &merge_plan_};
  for (int i = 0; i < 2; i++) {
    auto& plan = *plans[i];
    setup_plan(plan, i == 0 ? true : false, algo);

    plan.left_.row_cnt_ = left_row_count;
    plan.right_.row_cnt_ = right_row_count;
    plan.left_.string_size_ = string_size;
    plan.right_.string_size_ = string_size;
    if (&plan != &merge_plan_) {
      plan.left_.reverse_ = left_reverse;
      plan.right_.reverse_ = right_reverse;
    }
    plan.left_.idx_cnt_func_ = left_func;
    plan.right_.idx_cnt_func_ = right_func;

    ASSERT_EQ(OB_SUCCESS, plan.left_.test_init());
    ASSERT_EQ(OB_SUCCESS, plan.right_.test_init());
  }
}

void ObHashSetDumpTest::run_test(int64_t print_row_cnt)
{
  ObArenaAllocator alloc;
  typedef ObArray<int64_t*> ResArray;
  int64_t res_cell_cnt = SetDataGenerator::CELL_CNT * 2;
  auto fun = [&](SetPlan& plan, ResArray& res) -> void {
    ASSERT_EQ(OB_SUCCESS, plan.set_op_->open(plan.exec_ctx_));
    int ret = OB_SUCCESS;
    const ObNewRow* row = NULL;
    int64_t cnt = 0;
    while (OB_SUCC(ret)) {
      if (OB_FAIL(plan.set_op_->get_next_row(plan.exec_ctx_, row))) {
        ASSERT_EQ(OB_ITER_END, ret);
      } else {
        if (cnt < print_row_cnt) {
          LOG_INFO("join res", K(*row));
        }
        auto r = static_cast<int64_t*>(alloc.alloc(sizeof(int64_t) * res_cell_cnt));
        ASSERT_TRUE(NULL != r);
        for (int64_t i = 0; i < res_cell_cnt; i++) {
          auto& c = row->cells_[i];
          if (i < row->count_ && c.get_type() == ObIntType) {
            r[i] = c.get_int();
          } else {
            r[i] = -1;
          }
        }
        ASSERT_EQ(OB_SUCCESS, res.push_back(r));
      }
      cnt++;
    }
  };

  auto pfunc = [&](int64_t* r) {
    ObSqlString s;
    for (int64_t i = 0; i < res_cell_cnt; i++) {
      s.append_fmt("%ld, ", r[i]);
    }
    LOG_INFO("RES:", K(s.ptr()));
  };

  ResArray hash_res;
  fun(hash_plan_, hash_res);
  ASSERT_FALSE(HasFatalFailure());
  ResArray merge_res;
  fun(merge_plan_, merge_res);
  ASSERT_FALSE(HasFatalFailure());

  ASSERT_EQ(hash_res.count(), merge_res.count());
  auto sort_cmp = [&](int64_t* l, int64_t* r) {
    for (int64_t i = 0; i < res_cell_cnt; i++) {
      if (l[i] != r[i]) {
        return l[i] < r[i];
      }
    }
    return false;
  };
  std::sort(&hash_res.at(0), &hash_res.at(0) + hash_res.count(), sort_cmp);
  std::sort(&merge_res.at(0), &merge_res.at(0) + merge_res.count(), sort_cmp);
  for (int64_t i = 0; i < hash_res.count(); i++) {
    if (sort_cmp(hash_res.at(i), merge_res.at(i)) || sort_cmp(merge_res.at(i), hash_res.at(i))) {
      pfunc(hash_res.at(i));
      pfunc(merge_res.at(i));
      ASSERT_FALSE(true);
    }
  }

  hash_set_op_->close(hash_plan_.exec_ctx_);
  merge_set_op_->close(merge_plan_.exec_ctx_);
  // hash_plan_.~SetPlan();
  // merge_plan_.~SetPlan();
  ASSERT_EQ(OB_SUCCESS, blocksstable::ObTmpFileManager::get_instance().files_.map_.size());
}

int ObHashSetDumpTest::init_tenant_mgr()
{
  int ret = OB_SUCCESS;
  ObTenantManager& tm = ObTenantManager::get_instance();
  ObAddr self;
  oceanbase::rpc::frame::ObReqTransport req_transport(NULL, NULL);
  oceanbase::obrpc::ObSrvRpcProxy rpc_proxy;
  oceanbase::obrpc::ObCommonRpcProxy rs_rpc_proxy;
  oceanbase::share::ObRsMgr rs_mgr;
  uint64_t cluster_version = CLUSTER_VERSION_3000;
  common::ObClusterVersion::get_instance().update_cluster_version(cluster_version);
  EXPECT_EQ(cluster_version, common::ObClusterVersion::get_instance().get_cluster_version());
  int64_t tenant_id = OB_SYS_TENANT_ID;
  self.set_ip_addr("127.0.0.1", 8086);
  ret = ObTenantConfigMgr::get_instance().add_tenant_config(tenant_id);
  EXPECT_EQ(OB_SUCCESS, ret);
  ret = tm.init(self, rpc_proxy, rs_rpc_proxy, rs_mgr, &req_transport, &ObServerConfig::get_instance());
  EXPECT_EQ(OB_SUCCESS, ret);
  ret = tm.add_tenant(tenant_id);
  EXPECT_EQ(OB_SUCCESS, ret);
  ret = tm.set_tenant_mem_limit(tenant_id, 4L * 1024L * 1024L * 1024L, 8L * 1024L * 1024L * 1024L);
  EXPECT_EQ(OB_SUCCESS, ret);
  ret = tm.add_tenant(OB_SERVER_TENANT_ID);
  EXPECT_EQ(OB_SUCCESS, ret);
  const int64_t ulmt = 256LL << 30;
  const int64_t llmt = 256LL << 30;
  ret = tm.set_tenant_mem_limit(OB_SYS_TENANT_ID, ulmt, llmt);
  EXPECT_EQ(OB_SUCCESS, ret);
  ret = tm.set_tenant_mem_limit(OB_SERVER_TENANT_ID, ulmt, llmt);
  EXPECT_EQ(OB_SUCCESS, ret);
  lib::ObTenantCtxAllocator* ctx_allocator = lib::ObMallocAllocator::get_instance()->get_tenant_ctx_allocator(
      OB_SERVER_TENANT_ID, common::ObCtxIds::DEFAULT_CTX_ID);
  EXPECT_EQ(OB_SUCCESS, ret);
  ret = ctx_allocator->set_limit(8L * 1024L * 1024L * 1024L);
  EXPECT_EQ(OB_SUCCESS, ret);
  oceanbase::lib::set_memory_limit(128LL << 32);
  return ret;
}

TEST_F(ObHashSetDumpTest, test_single)
{
  setup_test(
      ObHashSetDumpTest::TestAlgo::UNION,
      512,
      1000,
      false,
      [](int64_t id, int64_t) { return id % 3 == 0 ? 1 : 0; },
      1000,
      false,
      [](int64_t id, int64_t) { return id % 5 == 0 ? 1 : 0; });
  ASSERT_FALSE(HasFatalFailure());
  run_test();
  ASSERT_FALSE(HasFatalFailure());
}

TEST_F(ObHashSetDumpTest, test_except)
{
  setup_test(
      ObHashSetDumpTest::TestAlgo::EXCEPT,
      512,
      1000,
      false,
      [](int64_t id, int64_t) { return id % 3 == 0 ? 1 : 0; },
      1000,
      false,
      [](int64_t id, int64_t) { return id % 5 == 0 ? 1 : 0; });
  ASSERT_FALSE(HasFatalFailure());
  run_test();
  ASSERT_FALSE(HasFatalFailure());
}

TEST_F(ObHashSetDumpTest, test_intersect)
{
  setup_test(
      ObHashSetDumpTest::TestAlgo::INTERSECT,
      512,
      1000,
      false,
      [](int64_t id, int64_t) { return id % 3 == 0 ? 1 : 0; },
      1000,
      false,
      [](int64_t id, int64_t) { return id % 5 == 0 ? 1 : 0; });
  ASSERT_FALSE(HasFatalFailure());
  run_test();
  ASSERT_FALSE(HasFatalFailure());
}

TEST_F(ObHashSetDumpTest, test_dump_union)
{
  setup_test(
      ObHashSetDumpTest::TestAlgo::UNION,
      2000,
      200000 * 3,
      false,
      [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
      200000 * 5,
      false,
      [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
  ASSERT_FALSE(HasFatalFailure());
  run_test();
  ASSERT_FALSE(HasFatalFailure());
}

TEST_F(ObHashSetDumpTest, test_dump_intersect)
{
  setup_test(
      ObHashSetDumpTest::TestAlgo::INTERSECT,
      2000,
      200000 * 3,
      false,
      [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
      200000 * 5,
      false,
      [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
  ASSERT_FALSE(HasFatalFailure());
  run_test();
  ASSERT_FALSE(HasFatalFailure());
}

TEST_F(ObHashSetDumpTest, test_dump_except)
{
  setup_test(
      ObHashSetDumpTest::TestAlgo::EXCEPT,
      2000,
      200000 * 3,
      false,
      [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
      200000 * 5,
      false,
      [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
  ASSERT_FALSE(HasFatalFailure());
  run_test();
  ASSERT_FALSE(HasFatalFailure());
}

// TEST_F(ObHashSetDumpTest, Size20M_union)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::UNION, 2000,
//       200000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
//       200000 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, Size20M_intersect)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::INTERSECT, 2000,
//       200000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
//       200000 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, Size20M_except)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::EXCEPT, 2000,
//       200000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
//       200000 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, test_more_data_union)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::UNION, 2000,
//       100000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
//       2000000, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, test_more_data_intersect)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::INTERSECT, 2000,
//       100000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
//       2000000, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, test_more_data_except)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::EXCEPT, 2000,
//       100000 * 3, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
//       2000000, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, test_bigger_left_union)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::UNION, 2000,
//       2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
//       2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, test_bigger_left_intersect)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::INTERSECT, 2000,
//       2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
//       2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, test_bigger_left_except)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::EXCEPT, 2000,
//       2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; },
//       2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, test_bigger_right_union)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::UNION, 2000,
//     2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; },
//     2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, test_bigger_right_intersect)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::INTERSECT, 2000,
//     2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; },
//     2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

// TEST_F(ObHashSetDumpTest, test_bigger_right_except)
// {
//   int64_t hash_mem = 0;
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ(100 * 1024 * 1024, hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(20* 1024 * 1024);

//   setup_test(ObHashSetDumpTest::TestAlgo::EXCEPT, 2000,
//     2 * 5, false, [](int64_t id, int64_t) { return id % 5 == 0 ? 2 : 0; },
//     2000000, false, [](int64_t id, int64_t) { return id % 3 == 0 ? 2 : 0; });
//   ASSERT_FALSE(HasFatalFailure());
//   run_test(10);
//   ASSERT_FALSE(HasFatalFailure());

//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((20 * 1024 * 1024), hash_mem);
//   TEST_SET_DUMP_SET_HASH_AREA_SIZE(100* 1024 * 1024);
//   hash_mem = TEST_SET_DUMP_GET_HASH_AREA_SIZE();
//   ASSERT_EQ((100 * 1024 * 1024), hash_mem);
// }

}  // namespace sql
}  // namespace oceanbase

int main(int argc, char** argv)
{
  oceanbase::sql::init_sql_factories();
  OB_LOGGER.set_log_level("INFO");
  ::testing::InitGoogleTest(&argc, argv);
  int ret = RUN_ALL_TESTS();
  OB_LOGGER.disable();
  return ret;
}