hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 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

436
unittest/sql/optimizer/ob_mock_opt_stat_manager.h Normal file
View File

@ -0,0 +1,436 @@
/**
* 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 _OB_OPT_MOCK_STAT_MANAGER_H
#define _OB_OPT_MOCK_STAT_MANAGER_H
#include "share/stat/ob_opt_column_stat_cache.h"
#include "share/stat/ob_opt_stat_manager.h"
#include "share/stat/ob_opt_stat_service.h"
#include "share/stat/ob_opt_table_stat.h"
#include "share/stat/ob_stat_manager.h"
#include "sql/resolver/ob_schema_checker.h"
#include "sql/optimizer/ob_opt_default_stat.h"
#include "lib/timezone/ob_time_convert.h"
namespace test {
// class MockOptTableStatService : public oceanbase::common::ObOptTableStatService
// {
// public:
// static const int64_t DEFAULT_ROW_COUNT = 100;
// static const int64_t DEFAULT_SSTABLE_ROW_COUNT = 50;
// static const int64_t DEFAULT_MEMTABLE_ROW_COUNT = 50;
// static const int64_t DEFAULT_ROW_SIZE = 100;
// static const int64_t DEFAULT_DATA_SIZE = DEFAULT_ROW_COUNT * DEFAULT_ROW_SIZE;
// static const int64_t DEFAULT_MACROC_BLOCKS = DEFAULT_ROW_COUNT * DEFAULT_ROW_SIZE / DEFAULT_MACRO_BLOCK_SIZE;
// static const int64_t DEFAULT_MICRO_BLOCKS = DEFAULT_DATA_SIZE / DEFAULT_MICRO_BLOCK_SIZE;
// MockOptTableStatService() {
// reset_table_stat();
// }
// virtual ~MockOptTableStatService() {}
//
// void reset_table_stat()
// {
// stat_.set_data_size(DEFAULT_DATA_SIZE);
// stat_.set_macro_block_num(DEFAULT_MACROC_BLOCKS);
// stat_.set_memtable_avg_row_size(DEFAULT_ROW_SIZE);
// stat_.set_memtable_row_count(DEFAULT_MEMTABLE_ROW_COUNT);
// stat_.set_micro_block_num(DEFAULT_MICRO_BLOCKS);
// stat_.set_sstable_avg_row_size(DEFAULT_ROW_SIZE);
// stat_.set_sstable_row_count(DEFAULT_SSTABLE_ROW_COUNT);
// }
//
// void set_table_stat(ObOptTableStat &table_stat)
// { stat_ = table_stat; }
//
// void set_table_row_count(int64_t row_count)
// {
// stat_.set_memtable_row_count(row_count);
// stat_.set_sstable_row_count(0);
// }
// private:
// ObOptTableStat stat_;
// };
//
// class MockOptColumnStatService : public oceanbase::common::ObOptColumnStatService
// {
// public:
// MockOptColumnStatService() {}
// virtual ~MockOptColumnStatService() {}
// int get_column_stat(const ObColumnStat::Key &key, const bool force_new, ObColumnStatValueHandle &handle)
// {
// UNUSED(key);
// UNUSED(force_new);
// UNUSED(handle);
// return OB_SUCCESS;
// }
//
// int get_column_stat(const ObColumnStat::Key &key, const bool force_new, ObColumnStat &cstat, ObIAllocator &alloc)
// {
// UNUSED(key);
// UNUSED(force_new);
// UNUSED(cstat);
// UNUSED(alloc);
// return OB_SUCCESS;
// }
//
// int get_batch_stat(const oceanbase::share::schema::ObTableSchema &table_schema,
// const uint64_t partition_id,
// ObIArray<ObColumnStat *> &stats,
// ObIAllocator &allocator)
// {
// UNUSED(table_schema);
// UNUSED(partition_id);
// UNUSED(stats);
// UNUSED(allocator);
//
// return OB_SUCCESS;
// }
//
// int update_column_stats(const ObIArray<ObColumnStat *> &column_stats)
// {
// UNUSED(column_stats);
// return OB_SUCCESS;
// }
// int update_column_stat(const ObColumnStat &cstat)
// {
// UNUSED(cstat);
// return OB_SUCCESS;
// }
//
// int refresh_column_stat(const int64_t data_version)
// {
// UNUSED(data_version);
// return OB_SUCCESS;
// }
//
// };
//
// class MockOptStatManager : public oceanbase::common::ObOptStatManager
// {
// static const uint64_t DEFAULT_TABLE1_ID = 1099511677777;
// static const uint64_t DEFAULT_TABLE2_ID = 1099511677778;
// static const int64_t TIME_MAX_VALUE = (3020399 * 1000000LL);
// static const int64_t DATE_MAX_VALUE = 2932896;
// static const int64_t DATE_MIN_VALUE = -354258;;
// public:
// struct ColumnStatInfo
// {
// ObObj min_;
// ObObj max_;
// int64_t distinct_num_;
// int64_t null_num_;
// void set_column_info(ObObj min, ObObj max, int64_t distinct_num, int64_t null_num)
// {
// min_ = min;
// max_ = max;
// distinct_num_ = distinct_num;
// null_num_ = null_num;
// }
// };
// MockOptStatManager() : schema_checker_(NULL)
// {
// column_stat_.set_num_distinct(10);
// ObObj min;
// min.set_int(0);
// ObObj max;
// max.set_int(20);
// int_info_.set_column_info(min, max, 10, 10);
// ObObj str_min;
// ObObj str_max;
// str_min.set_varchar("aa");
// str_max.set_varchar("az");
// str_info_.set_column_info(str_min, str_max, 80, 10);
// table1_row_count_ = 100;
// table2_row_count_ = 100;
// default_stat_ = false;
// }
// ~MockOptStatManager() {}
//
// void set_schema_checker(oceanbase::sql::ObSchemaChecker *schema_checker)
// { schema_checker_ = schema_checker; }
//
// void set_default_stat(bool is_default)
// {
// default_stat_ = is_default;
// }
//
// int get_table_stat(const ObPartitionKey &pkey, ObOptTableStat &tstat)
// {
// int ret = OB_SUCCESS;
// if (default_stat_) {
// tstat.set_memtable_row_count(0);
// tstat.set_sstable_row_count(0);
// } else if (DEFAULT_TABLE2_ID == pkey.get_table_id()) { // for opt_sel
// tstat.set_memtable_row_count(table2_row_count_);
// tstat.set_sstable_row_count(0);
// tstat.set_data_size(DEFAULT_ROW_SIZE * tstat.get_row_count());
// } else {
// tstat.set_memtable_row_count(table1_row_count_);
// tstat.set_sstable_row_count(0);
// tstat.set_data_size(DEFAULT_ROW_SIZE * tstat.get_row_count());
// }
// return ret;
// }
//
// virtual int get_column_stat(const uint64_t table_id,
// const uint64_t partition_id,
// const uint64_t column_id,
// ObOptColumnStatHandle &handle)
// {
// int ret = oceanbase::common::OB_SUCCESS;
// UNUSED(partition_id);
// UNUSED(handle);
// const oceanbase::share::schema::ObColumnSchemaV2 *col_schema = NULL;
// ObObj min;
// ObObj max;
// column_stat_.set_num_distinct(int_info_.distinct_num_);
// column_stat_.set_num_null(int_info_.null_num_);
// if (NULL != schema_checker_) {
// if (OB_FAIL(schema_checker_->get_column_schema(
// table_id, column_id, col_schema, true))) {
// COMMON_LOG(WARN, "Failed to get column schema", K(ret));
// } else if (NULL == col_schema) {
// ret = OB_ERR_UNEXPECTED;
// COMMON_LOG(WARN, "Col schema is NULL", K(ret));
// } else if (oceanbase::common::ObStringTC == col_schema->get_meta_type().get_type_class()) {
// column_stat_.set_num_distinct(str_info_.distinct_num_);
// column_stat_.set_num_null(str_info_.null_num_);
// min = str_info_.min_; // todo(yeti): special use, need deep copy
// max = str_info_.max_;
// } else if (col_schema->get_meta_type().get_type() >= ObDateTimeType
// && col_schema->get_meta_type().get_type() <= ObYearType) {
// switch (col_schema->get_meta_type().get_type()) {
// case ObDateTimeType: {
// min.set_datetime(DATETIME_MIN_VAL);
// max.set_datetime(DATETIME_MAX_VAL);
// break;
// }
// case ObTimestampType: {
// min.set_timestamp(DATETIME_MIN_VAL);
// max.set_timestamp(DATETIME_MAX_VAL);
// break;
// }
// case ObDateType: {
// min.set_date(DATE_MIN_VALUE);
// ObObj xx ;
// xx.set_varchar("9999-12-31");
// max.set_date(DATE_MAX_VALUE);
// break;
// }
// case ObTimeType: {
// min.set_time(ObTimeConverter::ZERO_TIME);
// max.set_time(TIME_MAX_VALUE);
// break;
// }
// case ObYearType: {
// uint8_t ymin = 0;
// ObTimeConverter::int_to_year(1970, ymin);
// min.set_year(ymin);
// uint8_t ymax = 0;
// ObTimeConverter::int_to_year(2155, ymax);
// max.set_year(ymax);
// break;
// }
// default: break;
// }
// } else {
// min = int_info_.min_;
// max = int_info_.max_;
// }
// }
// column_stat_.set_min_value(min);
// column_stat_.set_max_value(max);
// column_stat_.set_histogram(hist_);
// handle.stat_ = &column_stat_;
// return ret;
// }
//
// virtual int get_column_stat(const ObOptColumnStat::Key &key, ObOptColumnStatHandle &handle)
// {
// UNUSED(key);
// UNUSED(handle);
// return OB_SUCCESS;
// }
//
// int get_batch_stat(const oceanbase::share::schema::ObTableSchema &table_schema,
// const uint64_t partition_id,
// ObIArray<ObOptColumnStat *> &stats,
// ObIAllocator &allocator)
// {
// UNUSED(table_schema);
// UNUSED(partition_id);
// UNUSED(stats);
// UNUSED(allocator);
// return OB_SUCCESS;
// }
//
// void set_column_stat(int64_t distinct, ObObj min, ObObj max, int64_t null_num)
// {
// if (ObStringTC == min.get_type_class()) {
// str_info_.set_column_info(min, max, distinct, null_num);
// } else {
// int_info_.set_column_info(min, max, distinct, null_num);
// }
// }
//
// void set_table_stat(int64_t table1_row_count, int64_t table2_row_count)
// {
// table1_row_count_ = table1_row_count;
// table2_row_count_ = table2_row_count;
// }
//
// void set_histogram(ObHistogram *hist)
// {
// hist_ = hist;
// }
//
// private:
// oceanbase::sql::ObSchemaChecker *schema_checker_;
// ObOptColumnStat column_stat_;
// ObHistogram *hist_;
// int64_t table1_row_count_;
// int64_t table2_row_count_;
// ColumnStatInfo int_info_;
// ColumnStatInfo str_info_;
// bool default_stat_;
// };
class MockOptStatService : public oceanbase::common::ObOptStatService {
public:
static MockOptStatService& get_instance()
{
static MockOptStatService instance_;
return instance_;
}
MockOptStatService()
{
reset_table_stat();
}
virtual ~MockOptStatService()
{}
virtual int init(oceanbase::common::ObMySQLProxy* proxy, ObServerConfig* config)
{
UNUSED(proxy);
UNUSED(config);
return OB_SUCCESS;
}
virtual int get_table_stat(const ObOptTableStat::Key& key, ObOptTableStat& tstat)
{
UNUSED(key);
// UNUSED now;
tstat = tstat_;
return OB_SUCCESS;
}
virtual int get_column_stat(const ObOptColumnStat::Key& key, ObOptColumnStatHandle& handle)
{
UNUSED(key);
handle.stat_ = &cstat_;
return OB_SUCCESS;
}
virtual int load_column_stat_and_put_cache(const ObOptColumnStat::Key& key, ObOptColumnStatHandle& handle)
{
UNUSED(key);
UNUSED(handle);
return OB_SUCCESS;
}
virtual int load_table_stat_and_put_cache(const ObOptTableStat::Key& key, ObOptTableStatHandle& handle)
{
UNUSED(key);
UNUSED(handle);
return OB_SUCCESS;
}
ObOptColumnStat& get_column_stat()
{
return cstat_;
}
ObHistogram& get_histogram()
{
return hist_;
}
void use_histogram()
{
cstat_.set_histogram(&hist_);
}
void no_use_histogram()
{
cstat_.set_histogram(NULL);
}
void reset_table_stat()
{
tstat_ = oceanbase::common::ObOptStatManager::get_default_table_stat();
}
private:
ObOptTableStat tstat_;
ObOptColumnStat cstat_;
ObHistogram hist_;
};
class MockOptStatManager : public oceanbase::common::ObOptStatManager {
public:
static MockOptStatManager& get_instance()
{
static MockOptStatManager instance_;
return instance_;
}
virtual int init(ObOptStatService* stat_service, ObMySQLProxy* proxy, ObServerConfig* config)
{
inited_ = true;
stat_service_ = stat_service;
if (NULL != stat_service_) {
stat_service_->init(NULL, NULL);
}
UNUSED(proxy);
UNUSED(config);
return OB_SUCCESS;
}
// virtual int get_column_stat(const ObOptColumnStat::Key &key, ObOptColumnStatHandle &handle);
virtual int update_column_stat(const oceanbase::common::ObIArray<ObOptColumnStat*>& column_stats)
{
UNUSED(column_stats);
return OB_SUCCESS;
}
virtual int delete_column_stat(const oceanbase::common::ObIArray<ObOptColumnStat*>& column_stats)
{
UNUSED(column_stats);
return OB_SUCCESS;
}
virtual int refresh_column_stat(const ObOptColumnStat::Key& key)
{
UNUSED(key);
return OB_SUCCESS;
}
virtual int refresh_table_stat(const ObOptTableStat::Key& key)
{
UNUSED(key);
return OB_SUCCESS;
}
// virtual int get_table_stat(const ObOptTableStat::Key &key, ObOptTableStat &tstat);
virtual int add_refresh_stat_task(const oceanbase::obrpc::ObUpdateStatCacheArg& analyze_arg)
{
UNUSED(analyze_arg);
return OB_SUCCESS;
}
};
} // end namespace test
#endif /* _OB_MOCK_OPT_STAT_MANAGER_H */