oceanbase/unittest/sql/code_generator/test_static_engine_cg.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.
 */

#include <iterator>
#include <gtest/gtest.h>
#define private public
#include "sql/test_sql_utils.h"
#include "lib/container/ob_array.h"
#include "sql/code_generator/ob_code_generator.h"
#include "sql/ob_sql_init.h"
#include "sql/engine/dml/ob_table_insert.h"
#include "sql/optimizer/test_optimizer_utils.h"
#include "sql/plan_cache/ob_cache_object_factory.h"
#include "sql/engine/ob_phy_operator.h"
#include "sql/engine/ob_double_children_phy_operator.h"
#include "sql/engine/ob_multi_children_phy_operator.h"
#include "lib/worker.h"
#undef private
using namespace oceanbase::common;
using namespace oceanbase::share;

namespace test
{
class MockVisitor : public ObPhyOperatorVisitor
{
public:
  MockVisitor() : level_(0) {}
  ~MockVisitor() {}
  virtual int pre_visit(const ObSingleChildPhyOperator &op)
  {
    int ret = OB_SUCCESS;
    OB_LOG(INFO, "output:", K(level_), "type", op.get_type());
    level_++;
    return ret;
  }
  virtual int post_visit(const ObSingleChildPhyOperator &op)
  {
    level_--;
    const_cast<ObSingleChildPhyOperator&>(op).reuse();
    return OB_SUCCESS;
  }
  virtual int pre_visit(const ObDoubleChildrenPhyOperator &op)
  {
    int ret = OB_SUCCESS;
    OB_LOG(INFO, "output:", K(level_), "type", op.get_type());
    level_++;
    return ret;
  }
  virtual int post_visit(const ObDoubleChildrenPhyOperator &op)
  {
    level_--;
    const_cast<ObDoubleChildrenPhyOperator&>(op).reuse();
    return OB_SUCCESS;
  }
  virtual int pre_visit(const ObMultiChildrenPhyOperator &op)
  {
    int ret = OB_SUCCESS;
    OB_LOG(INFO, "output:", K(level_), "type", op.get_type());
    level_++;
    return ret;
  }
  virtual int post_visit(const ObMultiChildrenPhyOperator &op)
  {
    level_--;
    const_cast<ObMultiChildrenPhyOperator&>(op).reuse();
    return OB_SUCCESS;
  }
  virtual int pre_visit(const ObNoChildrenPhyOperator &op)
  {
    int ret = OB_SUCCESS;
    OB_LOG(INFO, "output:", K(level_), "type", op.get_type());
    level_++;
    return ret;
  }
  virtual int post_visit(const ObNoChildrenPhyOperator &op)
  {
    level_--;
    const_cast<ObNoChildrenPhyOperator&>(op).reuse();
    return OB_SUCCESS;
  }
  virtual int pre_visit(const ObPhyOperator &op)
  {
    int ret = OB_SUCCESS;
    OB_LOG(INFO, "output:", K(level_), "type", op.get_type());
    level_++;
    return ret;
  }
  virtual int post_visit(const ObPhyOperator &op)
  {
    level_--;
    const_cast<ObPhyOperator&>(op).reuse();
    return OB_SUCCESS;
  }
private:
  int level_;
};

class TestCodeGenerator: public TestOptimizerUtils
{
public:
  TestCodeGenerator();
  virtual ~TestCodeGenerator();
  virtual void SetUp();
  virtual void TearDown();
private:
  // disallow copy
  DISALLOW_COPY_AND_ASSIGN(TestCodeGenerator);
protected:
  // function members
  void do_optimize(ObStmt &stmt,
                   ObLogPlan *&plan,
                   ObPhyPlanType distr_method);
  void do_code_generate(const ObLogPlan &log_plan,
                        ObCodeGenerator &code_gen,
                        ObPhysicalPlan &phy_plan);
  int do_rewrite(ObStmt *&stmt, ObPhysicalPlan *phy_plan);
protected:
  // data members
  ParamStore params_;
  ObAddr addr_;
  ObOptimizerContext *optimizer_ctx_;
  ObTransformerCtx *transformer_ctx_;
  ObSchemaChecker schema_checker_;
  ObQueryHint query_hint_;
};

TestCodeGenerator::TestCodeGenerator()
    : optimizer_ctx_(NULL),
      transformer_ctx_(NULL)
{
  memcpy(schema_file_path_, "./test_code_generator.schema", sizeof("./test_code_generator.schema"));
}

TestCodeGenerator::~TestCodeGenerator()
{
}

void TestCodeGenerator::SetUp()
{
  TestOptimizerUtils::SetUp();
  schema_checker_.init(schema_guard_);
  exec_ctx_.get_sql_ctx()->schema_guard_ = &schema_guard_;
  exec_ctx_.get_sql_ctx()->session_info_ = &session_info_;
  optimizer_ctx_ = new ObOptimizerContext(&session_info_,
                                          &exec_ctx_,
                                          //schema_mgr_,
                                          &sql_schema_guard_,
                                          &stat_manager_,
                                          NULL,
                                          &partition_service_,
                                          allocator_,
                                          &part_cache_,
                                          &params_,
                                          addr_,
                                          NULL,
                                          query_hint_,
                                          expr_factory_,
                                          NULL,
                                          false,
                                          stmt_factory_.get_query_ctx());
  ASSERT_TRUE(optimizer_ctx_);
  transformer_ctx_ = new ObTransformerCtx();
  ASSERT_TRUE(transformer_ctx_);
  transformer_ctx_->allocator_ = &allocator_;
  transformer_ctx_->session_info_ = &session_info_;
  transformer_ctx_->schema_checker_ = &schema_checker_;
  transformer_ctx_->expr_factory_ = &expr_factory_;
  transformer_ctx_->stmt_factory_ = &stmt_factory_;
  transformer_ctx_->exec_ctx_ = &exec_ctx_;
  transformer_ctx_->partition_location_cache_ = &part_cache_;
  transformer_ctx_->stat_mgr_ = &stat_manager_;
  transformer_ctx_->partition_service_ = &partition_service_;
  transformer_ctx_->sql_schema_guard_ = &sql_schema_guard_;
  transformer_ctx_->self_addr_ = &addr_;
}

void TestCodeGenerator::TearDown()
{
  // destroy
  destroy();
  if (NULL != optimizer_ctx_) {
    delete optimizer_ctx_;
    optimizer_ctx_ = NULL;
  }
  if (NULL != transformer_ctx_) {
    delete transformer_ctx_;
    transformer_ctx_ = NULL;
  }
}

int TestCodeGenerator::do_rewrite(ObStmt *&stmt, ObPhysicalPlan *phy_plan)
{
  int ret = OB_SUCCESS;
  transformer_ctx_->phy_plan_ = phy_plan;
  ObTransformerImpl trans(transformer_ctx_);
  if (stmt->is_select_stmt()) {
    ObDMLStmt *dml_stmt = static_cast<ObDMLStmt *>(stmt);
    if (OB_FAIL(trans.transform(dml_stmt))) {
      _OB_LOG(WARN, "fail to transform stmt, ret = %d", ret);
    } else {
    stmt = dml_stmt;
  }
  }
  return ret;
}

void TestCodeGenerator::do_optimize(ObStmt &stmt,
                                    ObLogPlan *&plan,
                                    ObPhyPlanType distr)
{
  ObTableLocation table_location;

  OK(optimizer_ctx_->get_table_location_list().push_back(table_location));
  if (distr == OB_PHY_PLAN_REMOTE) {
    SQL_CG_LOG(DEBUG, "setting local address to 2.2.2.2");
    optimizer_ctx_->set_local_server_addr("2.2.2.2", 8888);
  } else {
    SQL_CG_LOG(DEBUG, "setting local address to 1.1.1.1");
    optimizer_ctx_->set_local_server_addr("1.1.1.1", 8888);
  }

  ObQueryHint query_hint = dynamic_cast<ObDMLStmt&>(stmt).get_stmt_hint().get_query_hint();
  optimizer_ctx_->set_query_hint(query_hint);
  optimizer_ctx_->set_root_stmt(dynamic_cast<ObDMLStmt*>(&stmt));
  optimizer_ctx_->get_all_exprs().reuse();
  ObOptimizer optimizer(*optimizer_ctx_);
  OK(optimizer.optimize(dynamic_cast<ObDMLStmt&>(stmt), plan));
  char buf[1024];
  plan->to_string(buf, 1024);
  _OB_LOG(INFO, "logical_plan=%s", buf);
}

void TestCodeGenerator::do_code_generate(const ObLogPlan &log_plan,
                                         ObCodeGenerator &code_gen,
                                         ObPhysicalPlan &phy_plan)
{
  OK(code_gen.generate(log_plan, phy_plan));
}

TEST_F(TestCodeGenerator, basic_test)
{
  const char* test_file = "./test_static_engine_cg.test";
  const char* result_file = "./test_static_engine_cg.result";
  const char* tmp_file = "./test_static_engine_cg.tmp";
  // run tests
  std::ifstream if_tests(test_file);
  ASSERT_TRUE(if_tests.is_open());
  std::ofstream of_result(tmp_file);
  ASSERT_TRUE(of_result.is_open());
  std::string line;
  ObStmt *stmt = NULL;
  ObLogPlan *logical_plan = NULL;
  ObPhysicalPlan *phy_plan = NULL;
  int64_t line_no = 1;

  while (std::getline(if_tests, line)) {
    if (line.size() <= 0) continue;
    if (line.at(0) == '#') continue;
    _OB_LOG(DEBUG, "================================================================");
    of_result << "[" << line_no++ << "] " ;
    of_result << line << std::endl;
    bool is_print = true;
    params_.reset();
    OB_LOG(INFO, "case:", K(line.c_str()));

    // if sql start with "oracle", use oracle compact mode.
    auto mode =  lib::Worker::CompatMode::MYSQL;
    std::string oracle("oracle");
    // trim left
    line.erase(line.begin(),std::find_if(line.begin(), line.end(),
                                         [](int ch) { return !std::isspace(ch); }));
    if (strncasecmp(oracle.c_str(), line.c_str(), oracle.size()) == 0) {
      mode = lib::Worker::CompatMode::ORACLE;
      line.erase(line.begin(), line.begin() + oracle.size());
    }
    lib::CompatModeGuard g(mode);

    ObPhysicalPlanCtx *pctx = exec_ctx_.get_physical_plan_ctx();
    ASSERT_TRUE(NULL != pctx);

    ObCodeGenerator code_gen(false/*use_jit*/,
                             true/*use static typing engine*/,
                             CLUSTER_VERSION_3000,
                             &(pctx->get_datum_param_store()));
    ObCacheObjectFactory::alloc(phy_plan);
    ASSERT_TRUE(NULL != (phy_plan));

    ASSERT_NO_FATAL_FAILURE(do_resolve(line.c_str(), stmt, is_print, JSON_FORMAT, OB_SUCCESS, false));
    ASSERT_EQ(OB_SUCCESS, do_rewrite(stmt, phy_plan));
    ASSERT_NO_FATAL_FAILURE(do_optimize(*stmt, logical_plan, OB_PHY_PLAN_LOCAL));
    ASSERT_NO_FATAL_FAILURE(do_code_generate(*logical_plan, code_gen, *phy_plan));
    of_result << CSJ(*phy_plan) << std::endl;
    ASSERT_TRUE(NULL != phy_plan->get_root_op_spec());
    // new engine do not generate old phy operators
    // ObPhyOperator *main_query = phy_plan->get_main_query();
    // ASSERT_TRUE(NULL != main_query);
    // MockVisitor visitor;
    // ASSERT_EQ(OB_SUCCESS, main_query->accept(visitor));
    //@todo ObPhysicalPlan::free(phy_plan);
    phy_plan = NULL;
    stmt_factory_.destory();
    expr_factory_.destory();
  }
  of_result.close();
  // verify results
  UNUSED(result_file);
  // TODO shengle, 暂时不对比结果， 仅用于调试, 后续会加入farm时会对比结果
  // ASSERT_NO_FATAL_FAILURE(TestSqlUtils::is_equal_content(tmp_file, result_file));
}
}

int main(int argc, char **argv)
{
  system("rm -rf test_static_engine_cg.log");
  OB_LOGGER.set_log_level("DEBUG");
  OB_LOGGER.set_file_name("test_static_engine_cg.log", true);
  ::oceanbase::sql::init_sql_factories();
  ::testing::InitGoogleTest(&argc,argv);
  test::parse_cmd_line_param(argc, argv, test::clp);
  return RUN_ALL_TESTS();
}