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

patch 4.0

Browse Source
This commit is contained in:
wangzelin.wzl
2022-10-24 10:34:53 +08:00
parent 4ad6e00ec3
commit 93a1074b0c
10533 changed files with 2588271 additions and 2299373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

316
unittest/sql/optimizer/test_optimizer.cpp
View File

@ -19,7 +19,7 @@
#include "observer/ob_req_time_service.h"
#include <test_optimizer_utils.h>
#define BUF_LEN 102400 // 100K
#define BUF_LEN 102400 // 100K
using std::cout;
using namespace oceanbase::lib;
using namespace oceanbase::json;
@ -27,13 +27,13 @@ using oceanbase::sql::ObTableLocation;
using namespace oceanbase::sql;
using namespace oceanbase::observer;
namespace test {
class TestOptimizer : public TestOptimizerUtils {
namespace test
{
class TestOptimizer :public TestOptimizerUtils
{
public:
TestOptimizer()
{}
~TestOptimizer()
{}
TestOptimizer(){}
~TestOptimizer(){}
};
////// insert, update, delete, select for update
// TEST_F(TestOptimizer, ob_optimizer_hierarchical_query)
@ -44,7 +44,7 @@ public:
// ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
// }
// TEST_F(TestOptimizer, ob_optimizer_merg)
//TEST_F(TestOptimizer, ob_optimizer_merg)
//{
// const char* test_file = "./test_optimizer_merge.sql";
// const char* result_file = "./test_optimizer_merge.result";
@ -69,6 +69,7 @@ TEST_F(TestOptimizer, ob_optimizer_select)
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
// explain format=json
TEST_F(TestOptimizer, ob_optimizer_explain_json)
{
@ -104,8 +105,7 @@ TEST_F(TestOptimizer, ob_default_stat_est)
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file, true));
}
inline bool double_eq(ObObj a, double b, double eps)
{
inline bool double_eq(ObObj a, double b, double eps) {
return fabs(a.get_double() - b) <= eps;
}
@ -114,51 +114,54 @@ 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
//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(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(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(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(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));
@ -171,8 +174,8 @@ TEST_F(TestOptimizer, string_scalar_convert)
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(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));
@ -180,13 +183,13 @@ TEST_F(TestOptimizer, string_scalar_convert)
// 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
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(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));
@ -194,23 +197,23 @@ TEST_F(TestOptimizer, string_scalar_convert)
// 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
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(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
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(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));
}
@ -218,8 +221,8 @@ TEST_F(TestOptimizer, string_scalar_convert)
TEST_F(TestOptimizer, sort_cost)
{
int ret = OB_SUCCESS;
// Sort cost test
// default row-shape : 10 ints, sort 3 ints
//Sort cost test
//default row-shape : 10 ints, sort 3 ints
double rows = 1000.0;
ObExprResType t_int;
double cost = 0.0;
@ -237,42 +240,45 @@ TEST_F(TestOptimizer, sort_cost)
}
const char* tmp_file = "./test_optimizer_sort_cost.tmp";
const char* result_file = "./test_optimizer_sort_cost.result";
ObSEArray<OrderItem, 1> order_items;
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
ObSortCostInfo cost_info(rows, width, 0, order_items, false);
ret = ObOptEstCost::cost_sort(cost_info, cost, ObOptEstCost::VECTOR_MODEL);
//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);
//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);
//add_cost=3398.460000000000, get_cost=4206.660000000000, real_sort_cost=3495.706846458661
ret = ObOptEstCost::cost_sort(cost_info, cost, ObOptEstCost::VECTOR_MODEL);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(11115 == cost);
//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);
//add_cost=33894.599999999999, get_cost=42048.599999999999, real_sort_cost=43696.335580733263
ret = ObOptEstCost::cost_sort(cost_info, cost, ObOptEstCost::VECTOR_MODEL);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(119654 == cost);
//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);
//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, cost, ObOptEstCost::VECTOR_MODEL);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(1283695 == cost);
//ASSERT_TRUE(1283695 == cost);
// Test for mixed types
//Test for mixed types
ObExprResType t_vc;
t_vc.set_varchar();
t_vc.set_length(255);
@ -299,170 +305,161 @@ TEST_F(TestOptimizer, sort_cost)
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);
//add_cost=1792.210480000000, get_cost=699.636980000000, real_sort_cost=558.160103197957
ret = ObOptEstCost::cost_sort(cost_info, cost, ObOptEstCost::VECTOR_MODEL);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(3065 == cost);
//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);
//add_cost=17832.104800000001, get_cost=6978.369799999999, real_sort_cost=7442.134709306095
ret = ObOptEstCost::cost_sort(cost_info, cost, ObOptEstCost::VECTOR_MODEL);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(32267 == cost);
//ASSERT_TRUE(32267 == cost);
rows = 100000.0;
// add_cost=178231.048000000039, get_cost=69765.697999999989, real_sort_cost=93026.683866326173
//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);
ret = ObOptEstCost::cost_sort(cost_info, cost, ObOptEstCost::VECTOR_MODEL);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(341038 == cost);
//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);
//add_cost=1782220.480000000214, get_cost=697638.979999999865, real_sort_cost=1116320.206395914080
ret = ObOptEstCost::cost_sort(cost_info, cost, ObOptEstCost::VECTOR_MODEL);
ASSERT_TRUE(OB_SUCCESS == ret);
of_result << cost << std::endl;
// ASSERT_TRUE(3596194 == cost);
//ASSERT_TRUE(3596194 == cost);
of_result.close();
// std::cout << "diff -u " << tmp_file << " " << result_file << std::endl;
//std::cout << "diff -u " << tmp_file << " " << result_file << std::endl;
TestSqlUtils::is_equal_content(tmp_file, result_file);
}
TEST_F(TestOptimizer, scan_cost)
{
TEST_F(TestOptimizer, scan_cost) {
ObCostTableScanInfo est_cost_info(OB_INVALID_ID, OB_INVALID_ID, OB_INVALID_ID);
ObTableMetaInfo table_meta_info(OB_INVALID_ID);
est_cost_info.table_meta_info_ = &table_meta_info;
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.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_ = 100000;
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;
est_cost_info.batch_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
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(502 == cost);
// condition 2 : scan more than 5 blocks
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(1718 == cost);
// the more rows, the bigger cost is
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(9845 == cost);
// the more rows, the bigger cost is
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(97496 == cost);
// the more columns, the bigger cost is
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(126709 == cost);
// the wider the table is, the bigger cost is
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(182992 == cost);
// scan index back
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(283235 == cost);
// get
type = common::ObSimpleBatch::T_GET;
//get
est_cost_info.batch_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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(6751 == cost);
// the more rows, the bigger cost is
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//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;
//Compare of scan and get at 1000 rows
//cost of get is roughly 10 times bigger than cost of scan at same row count
est_cost_info.batch_type_ = common::ObSimpleBatch::T_SCAN;
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(1718 == cost);
est_cost_info.batch_type_ = common::ObSimpleBatch::T_GET;
// the more columns, the bigger cost is
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(14041 == cost);
// get index back
//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);
ObOptEstCost::cost_table(est_cost_info, 1, access_row_count, access_row_count, cost, index_back_cost, ObOptEstCost::VECTOR_MODEL);
//std::cout << type << ',' << access_row_count << ',' << column_count << ',' << cost << std::endl;
// ASSERT_TRUE(27168 == cost);
}
// TEST_F(TestOptimizer, ob_optimizer_failed)
//TEST_F(TestOptimizer, ob_optimizer_failed)
//{
// const char* test_file = "./test_optimizer_failed.sql";
// ASSERT_NO_FATAL_FAILURE(run_fail_test(test_file));
@ -498,7 +495,7 @@ TEST_F(TestOptimizer, ob_optimizer_used_hint)
}
/*
todo:
todo(@ banliu.zyd): 功能还没有测全，暂时注释
TEST_F(TestOptimizer, ob_optimizer_hualong)
{
const char* test_file = "./test_optimizer_hualong.sql";
@ -516,6 +513,7 @@ TEST_F(TestOptimizer, ob_optimizer_hualong_default)
}
*/
TEST_F(TestOptimizer, ob_optimizer_topk)
{
const char* test_file = "./test_optimizer_topk.sql";
@ -525,12 +523,12 @@ TEST_F(TestOptimizer, ob_optimizer_topk)
ASSERT_NO_FATAL_FAILURE(run_test(test_file, result_file, tmp_file));
}
} // namespace test
int main(int argc, char** argv)
}
int main(int argc, char **argv)
{
// char c;
// std::cout<<"Press any key to continue..."<<std::endl;
// std::cin>>c;
//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;
@ -543,14 +541,16 @@ int main(int argc, char** argv)
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");
system("mkdir -p /tmp/sstable /tmp/clog /tmp/slog");
GCONF.datafile_size = 41943040;
// ObServer::get_instance().init(opts);
//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]);
::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();