oceanbase/unittest/sql/engine/test_engine.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_ENGINE
#include <iterator>
#include <gtest/gtest.h>
#include "sql/test_sql_utils.h"
#include "lib/container/ob_array.h"
#include "sql/ob_sql_init.h"
#include "sql/optimizer/test_optimizer_utils.h"
#include "sql/code_generator/ob_code_generator_impl.h"
#include "sql/plan_cache/ob_cache_object_factory.h"
#include "observer/ob_req_time_service.h"
namespace test
{
class TestEngine: public TestOptimizerUtils
{
public:
  TestEngine();
  virtual ~TestEngine();
  virtual void SetUp();
  virtual void TearDown();
private:
  // disallow copy
  DISALLOW_COPY_AND_ASSIGN(TestEngine);
protected:
  // function members
  void do_code_generate(const ObLogPlan &log_plan,
                        ObPhysicalPlan &phy_plan);
  int test_phy_plan(ObPhysicalPlan &plan);
protected:
  // data members
};

TestEngine::TestEngine()
{
  memcpy(schema_file_path_, "./test_engine.schema", sizeof("./test_engine.schema"));
}

TestEngine::~TestEngine()
{
}

void TestEngine::SetUp()
{
  TestOptimizerUtils::SetUp();
}

void TestEngine::TearDown()
{
  destroy();
}

void TestEngine::do_code_generate(const ObLogPlan &log_plan,
                                  ObPhysicalPlan &phy_plan)
{
  ObCodeGeneratorImpl code_gen(CLUSTER_VERSION_1500);
  OK(code_gen.generate(log_plan, phy_plan));
}

int TestEngine::test_phy_plan(ObPhysicalPlan &plan)
{
  UNUSED(plan);
  int ret = OB_SUCCESS;
  return ret;
}

TEST_F(TestEngine, basic_test)
{
  int ret = OB_SUCCESS;
  const char* test_file = "./test_engine.test";
  // run tests
  std::ifstream if_tests(test_file);
  ASSERT_TRUE(if_tests.is_open());
  std::string line;
  ObLogPlan *log_plan = NULL;
  ObPhysicalPlan *phy_plan = NULL;
  bool is_select = false;

  while (std::getline(if_tests, line)) {
    // handle query
    ObArenaAllocator allocator(ObModIds::TEST);
    ObResultSet result(session_info_, allocator);
    if (line.size() <= 0) continue;
    if (line.at(0) == '#') continue;
    ObString sql = ObString::make_string(line.c_str());
    ASSERT_NO_FATAL_FAILURE(generate_logical_plan(result, sql, line.c_str(), log_plan, is_select, true));
    ASSERT_TRUE(NULL != log_plan);
    ObCacheObjectFactory::alloc(phy_plan);
    ASSERT_TRUE(NULL != (phy_plan));
    ASSERT_NO_FATAL_FAILURE(do_code_generate(*log_plan, *phy_plan));

    _OB_LOG(DEBUG, "phy_plan=%s", CSJ(*phy_plan));

    // init exec ctx
    exec_ctx_.~ObExecContext();
    new (&exec_ctx_) ObExecContext(allocator);
    exec_ctx_.init_phy_op(phy_plan->get_phy_operator_size());
    ObTaskExecutorCtx &task_exec_ctx = exec_ctx_.get_task_exec_ctx();
    ObExecuteResult &exe_result = task_exec_ctx.get_execute_result();
    task_exec_ctx.set_min_cluster_version(CLUSTER_VERSION_1500);
    task_exec_ctx.set_partition_location_cache(&part_cache_);
    GCTX.par_ser_ = &partition_service_;
    task_exec_ctx.set_self_addr(optctx_->get_local_server_addr());
    common::ObSEArray<ObTablePartitionInfo *, 4> table_partition_info;
    EXPECT_TRUE(OB_SUCCESS == log_plan->get_global_table_partition_info(table_partition_info));
    task_exec_ctx.set_table_locations(table_partition_info);

    EXPECT_TRUE(OB_SUCCESS == exec_ctx_.create_physical_plan_ctx());
    GCTX.self_addr_seq_.set_addr(optctx_->get_local_server_addr());
    exec_ctx_.set_my_session(&session_info_);
    exec_ctx_.set_sql_ctx(&sql_ctx_);

    ObExecutor ob_exe;
    ob_exe.init(phy_plan);
    ASSERT_EQ(OB_SUCCESS, ob_exe.execute_plan(exec_ctx_));
    ASSERT_EQ(OB_SUCCESS, exe_result.open(exec_ctx_));
    if (phy_plan->get_stmt_type() == stmt::T_SELECT) {
      const ObNewRow *tmp_row = NULL;
      while(OB_SUCCESS == (ret = exe_result.get_next_row(exec_ctx_, tmp_row))) {
        SQL_EXE_LOG(INFO, "get a row", K(*tmp_row));
      }
      ASSERT_EQ(OB_ITER_END, ret);
    }
    ASSERT_EQ(OB_SUCCESS, ob_exe.close(exec_ctx_));
    ASSERT_EQ(OB_SUCCESS, exe_result.close(exec_ctx_));
    expr_factory_.destory();
    stmt_factory_.destory();
    ObCacheObjectFactory::free(phy_plan);
  }
}
}

int main(int argc, char **argv)
{
  system("rm -f test_engine.log");
  observer::ObReqTimeGuard req_timeinfo_guard;
  OB_LOGGER.set_log_level("INFO");
  OB_LOGGER.set_file_name("test_engine.log", true);
  ::oceanbase::sql::init_sql_factories();
  ::testing::InitGoogleTest(&argc,argv);
  return RUN_ALL_TESTS();
}