hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

init push

Browse Source
This commit is contained in:
oceanbase-admin
2021-05-31 22:56:52 +08:00
commit cea7de1475
7020 changed files with 5689869 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

559
unittest/sql/optimizer/test_optimizer.cpp Normal file
View File

@ -0,0 +1,559 @@
/**
* 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_OPT
#include "observer/ob_server.h"
#include "election/ob_election_async_log.h"
#include "clog/ob_clog_history_reporter.h"
#include "sql/optimizer/ob_opt_est_cost.h"
#include "sql/optimizer/ob_opt_est_utils.h"
#include "observer/ob_req_time_service.h"
#include <test_optimizer_utils.h>
#define BUF_LEN 102400 // 100K
using std::cout;
using namespace oceanbase::lib;
using namespace oceanbase::json;
using oceanbase::sql::ObTableLocation;
using namespace oceanbase::sql;
using namespace oceanbase::observer;
namespace test {
class TestOptimizer : public TestOptimizerUtils {
public:
TestOptimizer()
{}
~TestOptimizer()
{}
};
////// insert, update, delete, select for update
// TEST_F(TestOptimizer, ob_optimizer_hierarchical_query)
// {
// const char* test_file = "./test_optimizer_hierarchical_query.sql";
// const char* result_file = "./test_optimizer_hierarchical_query.result";
// const char* tmp_file = "./test_optimizer_hierarchical_query.tmp";
// ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
// }
// TEST_F(TestOptimizer, ob_optimizer_merg)
//{
// const char* test_file = "./test_optimizer_merge.sql";
// const char* result_file = "./test_optimizer_merge.result";
// const char* tmp_file = "./test_optimizer_merge.tmp";
// ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
//}
TEST_F(TestOptimizer, ob_optimizer_dml)
{
const char* test_file = "./test_optimizer_dml.sql";
const char* result_file = "./test_optimizer_dml.result";
const char* tmp_file = "./test_optimizer_dml.tmp";
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
// select
TEST_F(TestOptimizer, ob_optimizer_select)
{
const char* test_file = "./test_optimizer_select.sql";
const char* result_file = "./test_optimizer_select.result";
const char* tmp_file = "./test_optimizer_select.tmp";
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
// explain format=json
TEST_F(TestOptimizer, ob_optimizer_explain_json)
{
const char* test_file = "./test_optimizer_explain_json.sql";
const char* result_file = "./test_optimizer_explain_json.result";
const char* tmp_file = "./test_optimizer_explain_json.tmp";
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
// explain extended
TEST_F(TestOptimizer, ob_optimizer_explain_extended)
{
const char* test_file = "./test_optimizer_explain_extended.sql";
const char* result_file = "./test_optimizer_explain_extended.result";
const char* tmp_file = "./test_optimizer_explain_extended.tmp";
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
// filter before index back extended
TEST_F(TestOptimizer, ob_optimizer_filter_before_indexback)
{
const char* test_file = "./test_filter_before_indexback.sql";
const char* result_file = "./test_filter_before_indexback.result";
const char* tmp_file = "./test_filter_before_indexback.tmp";
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
TEST_F(TestOptimizer, ob_default_stat_est)
{
const char* test_file = "./test_optimizer_default_stat.sql";
const char* result_file = "./test_optimizer_default_stat.result";
const char* tmp_file = "./test_optimizer_default_stat.tmp";
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file, true));
}
inline bool double_eq(ObObj a, double b, double eps)
{
return fabs(a.get_double() - b) <= eps;
}
TEST_F(TestOptimizer, string_scalar_convert)
{
int ret = OB_SUCCESS;
ObObj min, max, start, end;
ObObj mins, maxs, starts, ends;
// Standard case : number only, base = 10
min.set_varchar("123400000");
max.set_varchar("123500000");
start.set_varchar("123450000");
end.set_varchar("123470000");
ASSERT_TRUE(
OB_SUCC(ObOptEstObjToScalar::convert_objs_to_scalars(&min, &max, &start, &end, &mins, &maxs, &starts, &ends)));
ASSERT_TRUE(double_eq(mins, 0.4, 0.0001));
ASSERT_TRUE(double_eq(maxs, 0.5, 0.0001));
ASSERT_TRUE(double_eq(starts, 0.45, 0.0001));
ASSERT_TRUE(double_eq(ends, 0.47, 0.0001));
min.set_varchar("123");
max.set_varchar("123500000");
start.set_varchar("123450000");
end.set_varchar("123470000");
ASSERT_TRUE(
OB_SUCC(ObOptEstObjToScalar::convert_objs_to_scalars(&min, &max, &start, &end, &mins, &maxs, &starts, &ends)));
ASSERT_TRUE(double_eq(mins, 0, 0.0001));
ASSERT_TRUE(double_eq(maxs, 0.5, 0.0001));
ASSERT_TRUE(double_eq(starts, 0.45, 0.0001));
ASSERT_TRUE(double_eq(ends, 0.47, 0.0001));
min.set_varchar("1");
max.set_varchar("123500000");
start.set_varchar("123450000");
end.set_varchar("123470000");
ASSERT_TRUE(
OB_SUCC(ObOptEstObjToScalar::convert_objs_to_scalars(&min, &max, &start, &end, &mins, &maxs, &starts, &ends)));
ASSERT_TRUE(double_eq(mins, 0, 0.0001));
ASSERT_TRUE(double_eq(maxs, 0.235, 0.00001));
ASSERT_TRUE(double_eq(starts, 0.2345, 0.00001));
ASSERT_TRUE(double_eq(ends, 0.2347, 0.00001));
min.set_varchar("123400000");
max.set_varchar("123500000");
start.set_varchar("120000");
end.set_varchar("123470000");
ASSERT_TRUE(
OB_SUCC(ObOptEstObjToScalar::convert_objs_to_scalars(&min, &max, &start, &end, &mins, &maxs, &starts, &ends)));
ASSERT_TRUE(double_eq(mins, 0.34, 0.0001));
ASSERT_TRUE(double_eq(maxs, 0.35, 0.00001));
ASSERT_TRUE(double_eq(starts, 0, 0.00001));
ASSERT_TRUE(double_eq(ends, 0.347, 0.00001));
// upper character : base = 26
min.set_varchar("AAAA");
max.set_varchar("KKKK");
start.set_varchar("CCCC");
end.set_varchar("FFFF");
ASSERT_TRUE(
OB_SUCC(ObOptEstObjToScalar::convert_objs_to_scalars(&min, &max, &start, &end, &mins, &maxs, &starts, &ends)));
ASSERT_TRUE(double_eq(mins, 0, 0.00001));
ASSERT_TRUE(double_eq(maxs, 0.4, 0.00001));
ASSERT_TRUE(double_eq(starts, 0.08, 0.00001));
ASSERT_TRUE(double_eq(ends, 0.2, 0.00001));
// lower character : base = 26
min.set_varchar("aaaa"); // a = 97
max.set_varchar("kkkk"); // k = 107
start.set_varchar("cccc"); // c = 99
end.set_varchar("ffff"); // f = 102
ASSERT_TRUE(
OB_SUCC(ObOptEstObjToScalar::convert_objs_to_scalars(&min, &max, &start, &end, &mins, &maxs, &starts, &ends)));
ASSERT_TRUE(double_eq(mins, 0, 0.00001));
ASSERT_TRUE(double_eq(maxs, 0.4, 0.00001));
ASSERT_TRUE(double_eq(starts, 0.08, 0.00001));
ASSERT_TRUE(double_eq(ends, 0.2, 0.00001));
// lower character number mixed : base = 122 - 48 + 1 = 75
min.set_varchar("a7aa"); // a = 97
max.set_varchar("kk1k"); // k = 107
start.set_varchar("c0cc"); // c = 99
end.set_varchar("fff6"); // f = 102
ASSERT_TRUE(
OB_SUCC(ObOptEstObjToScalar::convert_objs_to_scalars(&min, &max, &start, &end, &mins, &maxs, &starts, &ends)));
ASSERT_TRUE(double_eq(mins, 0.654695, 0.00001));
ASSERT_TRUE(double_eq(maxs, 0.797160, 0.00001));
ASSERT_TRUE(double_eq(starts, 0.680123, 0.00001));
ASSERT_TRUE(double_eq(ends, 0.729728, 0.00001));
// other char number mixed, base = width([0-9] union [CHAR_OCCURED])
start.set_varchar("123@4.56"); //. = 46 @ = 64 base = 19
end.set_varchar("123123@4.56");
ASSERT_TRUE(
OB_SUCC(ObOptEstObjToScalar::convert_objs_to_scalars(NULL, NULL, &start, &end, NULL, NULL, &starts, &ends)));
ASSERT_TRUE(double_eq(starts, 0.964046, 0.00001));
ASSERT_TRUE(double_eq(ends, 0.169845, 0.00001));
}
TEST_F(TestOptimizer, sort_cost)
{
int ret = OB_SUCCESS;
// Sort cost test
// default row-shape : 10 ints, sort 3 ints
double rows = 1000.0;
ObExprResType t_int;
double cost = 0.0;
t_int.set_int();
ObSEArray<ObExprResType, 10> row_types;
double width = 4 * 10;
ObSEArray<ObExprResType, 3> sort_types;
for (int64_t i = 0; i < 10; ++i) {
row_types.push_back(t_int);
}
for (int64_t i = 0; i < 3; ++i) {
sort_types.push_back(t_int);
}
const char* tmp_file = "./test_optimizer_sort_cost.tmp";
const char* result_file = "./test_optimizer_sort_cost.result";
std::ofstream of_result(tmp_file);
ASSERT_TRUE(of_result.is_open());
ObSortCostInfo cost_info(rows, width, 0, NULL);
ret = ObOptEstCost::cost_sort(cost_info, sort_types, cost);
// add_cost=348.846000000000, get_cost=422.466000000000, real_sort_cost=262.178013484400
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(1048 == cost);
rows = 10000.0;
cost_info.rows_ = rows;
// add_cost=3398.460000000000, get_cost=4206.660000000000, real_sort_cost=3495.706846458661
ret = ObOptEstCost::cost_sort(cost_info, sort_types, cost);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(11115 == cost);
rows = 100000.0;
cost_info.rows_ = rows;
// add_cost=33894.599999999999, get_cost=42048.599999999999, real_sort_cost=43696.335580733263
ret = ObOptEstCost::cost_sort(cost_info, sort_types, cost);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(119654 == cost);
rows = 1000000.0;
cost_info.rows_ = rows;
// We see that even at rows = 1000000, row_store cost is still larger than real sort cost, even not
// counting cost of cache/TLB miss
// add_cost=338856.000000000000, get_cost=420467.999999999942, real_sort_cost=524356.026968799182
ret = ObOptEstCost::cost_sort(cost_info, sort_types, cost);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(1283695 == cost);
// Test for mixed types
ObExprResType t_vc;
t_vc.set_varchar();
t_vc.set_length(255);
ObExprResType t_num;
t_num.set_number();
ObExprResType t_ts;
t_ts.set_timestamp();
row_types.push_back(t_vc);
row_types.push_back(t_vc);
row_types.push_back(t_vc);
row_types.push_back(t_num);
row_types.push_back(t_num);
row_types.push_back(t_ts);
row_types.push_back(t_ts);
sort_types.reset();
sort_types.push_back(t_vc);
sort_types.push_back(t_num);
sort_types.push_back(t_int);
sort_types.push_back(t_ts);
rows = 1000.0;
width = 255 + 16 + 16;
cost_info.rows_ = rows;
cost_info.width_ = width;
// add_cost=1792.210480000000, get_cost=699.636980000000, real_sort_cost=558.160103197957
ret = ObOptEstCost::cost_sort(cost_info, sort_types, cost);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(3065 == cost);
rows = 10000.0;
cost_info.rows_ = rows;
// add_cost=17832.104800000001, get_cost=6978.369799999999, real_sort_cost=7442.134709306095
ret = ObOptEstCost::cost_sort(cost_info, sort_types, cost);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(32267 == cost);
rows = 100000.0;
// add_cost=178231.048000000039, get_cost=69765.697999999989, real_sort_cost=93026.683866326173
cost_info.rows_ = rows;
ret = ObOptEstCost::cost_sort(cost_info, sort_types, cost);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(341038 == cost);
rows = 1000000.0;
cost_info.rows_ = rows;
// add_cost=1782220.480000000214, get_cost=697638.979999999865, real_sort_cost=1116320.206395914080
ret = ObOptEstCost::cost_sort(cost_info, sort_types, cost);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(3596194 == cost);
of_result.close();
// std::cout << "diff -u " << tmp_file << " " << result_file << std::endl;
TestSqlUtils::is_equal_content(tmp_file, result_file);
}
TEST_F(TestOptimizer, scan_cost)
{
ObCostTableScanInfo est_cost_info(OB_INVALID_ID, OB_INVALID_ID, OB_INVALID_ID);
double STANDARD_SCHEMA_COL_COUNT = 50;
est_cost_info.table_meta_info_.micro_block_size_ = 16384;
est_cost_info.table_meta_info_.table_rowkey_count_ = 3;
est_cost_info.table_meta_info_.table_row_count_ = OB_EST_DEFAULT_ROW_COUNT;
est_cost_info.table_meta_info_.part_count_ = 1;
est_cost_info.table_meta_info_.cost_est_type_ = OB_DEFAULT_STAT_EST;
est_cost_info.index_meta_info_.index_part_size_ = OB_EST_DEFAULT_DATA_SIZE;
est_cost_info.index_meta_info_.index_micro_block_size_ = 16384;
common::ObSimpleBatch::ObBatchType type = common::ObSimpleBatch::T_SCAN;
bool index_back = false;
int64_t column_count = 0;
double access_row_count = 0.0;
double cost = 0;
double index_back_cost = 0;
// Temporary:if a scan has a full open range(min to max), it will be given a small increase of
// cost, leading optimizer to prefer access paths with ranges. 2 conditions to trigger.
// condition 1 : scan without range
est_cost_info.index_meta_info_.index_column_count_ = static_cast<int64_t>(STANDARD_SCHEMA_COL_COUNT);
column_count = 10;
access_row_count = 500.0;
index_back = false;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(1266 == cost);
est_cost_info.index_meta_info_.index_column_count_ = static_cast<int64_t>(STANDARD_SCHEMA_COL_COUNT);
column_count = 10;
access_row_count = 500.0;
index_back = false;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(502 == cost);
// condition 2 : scan more than 5 blocks
est_cost_info.index_meta_info_.index_column_count_ = static_cast<int64_t>(STANDARD_SCHEMA_COL_COUNT);
column_count = 10;
access_row_count = 1000.0;
index_back = false;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(1718 == cost);
// the more rows, the bigger cost is
access_row_count = 10000.0;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(9845 == cost);
// the more rows, the bigger cost is
access_row_count = 100000.0;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(97496 == cost);
// the more columns, the bigger cost is
column_count = 20;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(126709 == cost);
// the wider the table is, the bigger cost is
est_cost_info.index_meta_info_.index_column_count_ = 2 * static_cast<int64_t>(STANDARD_SCHEMA_COL_COUNT);
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(182992 == cost);
// scan index back
index_back = true;
est_cost_info.postfix_filter_sel_ = 0.1;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(283235 == cost);
// get
type = common::ObSimpleBatch::T_GET;
est_cost_info.postfix_filter_sel_ = 1.0;
est_cost_info.index_meta_info_.index_column_count_ = static_cast<int64_t>(STANDARD_SCHEMA_COL_COUNT);
column_count = 10;
access_row_count = 500.0;
index_back = false;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(6751 == cost);
// the more rows, the bigger cost is
access_row_count = 1000;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(13503 == cost);
// Compare of scan and get at 1000 rows
// cost of get is roughly 10 times bigger than cost of scan at same row count
type = common::ObSimpleBatch::T_SCAN;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(1718 == cost);
type = common::ObSimpleBatch::T_GET;
// the more columns, the bigger cost is
column_count = 20;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(14041 == cost);
// get index back
index_back = true;
ObOptEstCost::cost_table_one_batch(
est_cost_info, type, index_back, column_count, access_row_count, access_row_count, cost, index_back_cost);
// std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(27168 == cost);
}
// TEST_F(TestOptimizer, ob_optimizer_failed)
//{
// const char* test_file = "./test_optimizer_failed.sql";
// ASSERT_NO_FATAL_FAILURE(run_fail_test(test_file));
//}
// hint
TEST_F(TestOptimizer, ob_optimizer_hint)
{
const char* test_file = "./test_optimizer_hint.sql";
const char* result_file = "./test_optimizer_hint.result";
const char* tmp_file = "./test_optimizer_hint.tmp";
explain_type_ = EXPLAIN_OUTLINE;
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
TEST_F(TestOptimizer, ob_optimizer_outline)
{
const char* test_file = "./test_optimizer_outline.sql";
const char* result_file = "./test_optimizer_outline.result";
const char* tmp_file = "./test_optimizer_outline.tmp";
explain_type_ = EXPLAIN_OUTLINE;
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
TEST_F(TestOptimizer, ob_optimizer_used_hint)
{
const char* test_file = "./test_optimizer_used_hint.sql";
const char* result_file = "./test_optimizer_used_hint.result";
const char* tmp_file = "./test_optimizer_used_hint.tmp";
explain_type_ = EXPLAIN_EXTENDED;
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
/*
todo:
TEST_F(TestOptimizer, ob_optimizer_hualong)
{
const char* test_file = "./test_optimizer_hualong.sql";
const char* result_file = "./test_optimizer_hualong.result";
const char* tmp_file = "./test_optimizer_hualong.tmp";
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
TEST_F(TestOptimizer, ob_optimizer_hualong_default)
{
const char* test_file = "./test_optimizer_hualong.sql";
const char* result_file = "./test_optimizer_hualong.result";
const char* tmp_file = "./test_optimizer_hualong.tmp";
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file, true));
}
*/
TEST_F(TestOptimizer, ob_optimizer_topk)
{
const char* test_file = "./test_optimizer_topk.sql";
const char* result_file = "./test_optimizer_topk.result";
const char* tmp_file = "./test_optimizer_topk.tmp";
explain_type_ = EXPLAIN_EXTENDED;
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
} // namespace test
int main(int argc, char** argv)
{
// char c;
// std::cout<<"Press any key to continue..."<<std::endl;
// std::cin>>c;
set_memory_limit(10L << 30);
system("rm -rf test_optimizer.log");
observer::ObReqTimeGuard req_timeinfo_guard;
OB_LOGGER.set_log_level("INFO");
OB_LOGGER.set_file_name("test_optimizer.log", true);
ObServerOptions opts;
opts.cluster_id_ = 1;
opts.rs_list_ = "127.0.0.1:1";
opts.zone_ = "test1";
opts.data_dir_ = "/tmp";
opts.mysql_port_ = 23000 + getpid() % 1000;
opts.rpc_port_ = 24000 + getpid() % 1000;
system("mkdir -p /tmp/sort_dir /tmp/sstable /tmp/ilog /tmp/clog /tmp/slog");
GCONF.datafile_size = 41943040;
// ObServer::get_instance().init(opts);
oceanbase::sql::init_sql_factories();
::testing::InitGoogleTest(&argc, argv);
if (argc >= 2) {
if (strcmp("DEBUG", argv[1]) == 0 || strcmp("WARN", argv[1]) == 0)
OB_LOGGER.set_log_level(argv[1]);
}
test::parse_cmd_line_param(argc, argv, test::clp);
int ret = RUN_ALL_TESTS();
OB_LOGGER.set_log_level("ERROR");
return ret;
}