oceanbase/unittest/sql/test_sql_utils.h

/**
 * 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.
 */

#ifndef TEST_SQL_UTILS_H_
#define TEST_SQL_UTILS_H_

#undef private
#undef protected
#include <fstream>
#include <dirent.h>
#include <getopt.h>
#include <gtest/gtest.h>
#define private public
#define protected public
#include "lib/allocator/page_arena.h"
#include "lib/allocator/ob_fifo_allocator.h"
#include "lib/utility/ob_test_util.h"
#include "lib/json/ob_json_print_utils.h"  // for SJ
#include "share/inner_table/ob_inner_table_schema.h"
#include "share/ob_rpc_struct.h"
#include "share/schema/ob_schema_getter_guard.h"
#include "sql/parser/ob_parser.h"
#include "sql/resolver/ob_resolver.h"
#include "sql/resolver/ob_schema_checker.h"
#include "sql/resolver/ddl/ob_create_table_stmt.h"
#include "sql/resolver/ddl/ob_drop_table_stmt.h"
#include "sql/resolver/ddl/ob_create_index_stmt.h"
#include "sql/resolver/ddl/ob_create_database_stmt.h"
#include "sql/resolver/ddl/ob_use_database_stmt.h"
#include "sql/session/ob_sql_session_info.h"
#include "sql/resolver/dcl/ob_create_user_stmt.h"
#include "sql/optimizer/ob_log_plan_factory.h"
#include "sql/executor/ob_task_executor_ctx.h"
#include "sql/ob_sql_context.h"
#include "sql/engine/ob_exec_context.h"
#include "../share/schema/mock_schema_service.h"

using namespace oceanbase;
using namespace oceanbase::common;
using namespace oceanbase::share;
using namespace oceanbase::share::schema;
using namespace oceanbase::obrpc;
using namespace oceanbase::sql;

#define CSJ(x) (static_cast<const char *>(SJ((x))))
namespace test
{
typedef common::ParamStore ParamStore;
static const int32_t FILE_PATH_LEN = 512;
static const int32_t MAX_FILE_NUM = 128;
struct CmdLineParam
{
  CmdLineParam()
  {
    file_count = 0;
    test_input_from_cmd = false;
    print_schema_detail_info = false;
    record_test_result = false;
    sql_mode = DEFAULT_MYSQL_MODE;
  }
  char file_names[MAX_FILE_NUM][FILE_PATH_LEN];
  int32_t file_count;
  bool test_input_from_cmd;
  bool print_schema_detail_info;
  bool record_test_result;
  ObSQLMode sql_mode;
  std::vector<const char*> file_names_vector;
};
extern CmdLineParam clp;


extern bool comparisonFunc(const char *c1, const char *c2);
extern void load_sql_file(const char* file_name);
extern void load_all_sql_files(const char* directory_name);
extern void print_help_msg (const char* exe_name);
extern void parse_cmd_line_param(int argc, char *argv[], CmdLineParam &clp);

inline bool casesame_cstr(const char *a, const char *b)
{
  size_t len1 = strlen(a);
  size_t len2 = strlen(b);
  return (len1 == len2) && (strncasecmp(a, b, len1) == 0);
}

enum ParserResultFormat
{
  TREE_FORMAT,
  JSON_FORMAT
};

class TestSqlUtils
{
public:
  TestSqlUtils();
  virtual ~TestSqlUtils(){}
  virtual void init();
  virtual void destroy();
public:
  static const int64_t MAX_SCHEMA_FILE_PATH = 128 - 1;
// function members
  void load_schema_from_file(const char *file_path);
  void do_load_sql(const char *query_str, ObStmt *&stmt, bool is_print,  ParserResultFormat format = TREE_FORMAT, int64_t expect_error = OB_SUCCESS, int64_t case_line = 0);
  void do_resolve(const char* query, ObStmt *&stmt, bool is_print = false,
                  ParserResultFormat format = JSON_FORMAT, int64_t expect_error = OB_SUCCESS,
                  bool parameterized = true, bool need_replace_param_expr = true, int64_t case_line = 0);
  int create_system_table();
  void create_system_db();
  void do_create_table(const char *query_str);
  void do_create_table(ObStmt *&stmt);
  void do_drop_table(ObStmt *&stmt);
  void do_create_index(ObStmt *&stmt);
  void do_create_database(ObStmt *&stmt);
  void do_use_database(ObStmt *&stmt);
  void do_create_user(ObStmt *&stmt);
  void generate_index_schema(ObCreateIndexStmt &stmt);
  void generate_index_column_schema(ObCreateIndexStmt &stmt, ObTableSchema &index_schema);
  int get_hidden_column_value(ObResolverParams &resolver_ctx, ParamStore &params);
  void is_equal_content(const char* tmp_file, const char* result_file);
  uint64_t get_next_table_id(const uint64_t user_tenant_id);
  int add_table_schema(ObTableSchema &table_schema);
  int add_database_schema(ObDatabaseSchema &database_schema);
  int drop_table_schema(const ObTableSchema &table_schema);
  int parse_row_from_json(const ObString &json_str, ObString &table_name, ObIArray<ObSEArray<ObObj, 3> > &row_array);
  int parse_json_array(json::Value &value, ObIArray<ObSEArray<ObObj, 3> > &row_array);
  ObSqlSchemaGuard &get_sql_schema_guard() { return sql_schema_guard_; }
  ObSchemaGetterGuard &get_schema_guard() { return schema_guard_; }
public:
  //table id
  hash::ObHashMap<uint64_t,uint64_t> next_user_table_id_map_;
  //user_id
  uint64_t sys_user_id_;
  uint64_t next_user_id_;
  //database_id
  uint64_t sys_database_id_;
  uint64_t next_user_database_id_;
  //tenant_id
  uint64_t sys_tenant_id_;
  ObSEArray<ObObj, 16> sys_view_bigint_param_list_;
  int64_t schema_version_;
  char schema_file_path_[MAX_SCHEMA_FILE_PATH + 1];
  ObSQLSessionInfo session_info_;
  ObSqlSchemaGuard sql_schema_guard_;
  share::schema::ObSchemaGetterGuard schema_guard_;
  MockSchemaService *schema_service_;
  ObArenaAllocator allocator_;
  ObRawExprFactory expr_factory_;
  ObStmtFactory stmt_factory_;
  ObLogPlanFactory log_plan_factory_;
  ObSqlCtx sql_ctx_;
  ObExecContext exec_ctx_;
  ParamStore param_list_;
private:
  DISALLOW_COPY_AND_ASSIGN(TestSqlUtils);
};
}
#endif