218 lines
8.0 KiB
C++
218 lines
8.0 KiB
C++
/**
|
|
* 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 <gtest/gtest.h>
|
|
#include "common/object/ob_object.h"
|
|
#include "common/row/ob_row.h"
|
|
#include "sql/ob_sql_init.h"
|
|
#include "sql/engine/expr/ob_sql_expression.h"
|
|
#include "sql/engine/ob_phy_operator.h"
|
|
#include "sql/engine/ob_single_child_phy_operator.h"
|
|
#include "sql/engine/ob_no_children_phy_operator.h"
|
|
#include "sql/engine/ob_physical_plan.h"
|
|
#include "sql/engine/aggregate/ob_merge_groupby.h"
|
|
#include "sql/engine/ob_exec_context.h"
|
|
#include "sql/session/ob_sql_session_info.h"
|
|
|
|
using namespace oceanbase;
|
|
using namespace oceanbase::sql;
|
|
using namespace oceanbase::common;
|
|
using namespace ::testing;
|
|
class MockSqlExpression : public common::ObDLinkBase<ObSqlExpression>
|
|
{
|
|
public:
|
|
static ObSqlExpression *alloc();
|
|
static void free(ObSqlExpression *ptr);
|
|
protected:
|
|
friend class ::ObAggregateFunctionTest;
|
|
// data members
|
|
ObPostfixExpression post_expr_;
|
|
};
|
|
typedef common::ObGlobalFactory<MockSqlExpression, 1, common::ObModIds::OB_SQL_EXPR>
|
|
MockSqlExpressionFactory;
|
|
typedef common::ObTCFactory < MockSqlExpression, 1, common::ObModIds::OB_SQL_EXPR, 1 << 24,
|
|
8192 > MockSqlExpressionTCFactory;
|
|
inline MockSqlExpression *MockSqlExpression::alloc()
|
|
{
|
|
return MockSqlExpressionTCFactory::get_instance()->get(MockSqlExpression::EXPR_TYPE_SQL);
|
|
}
|
|
|
|
inline void MockSqlExpression::free(MockSqlExpression *expr)
|
|
{
|
|
if (OB_LIKELY(expr)) {
|
|
expr->prev_ = expr->next_ = NULL;
|
|
}
|
|
MockSqlExpressionTCFactory::get_instance()->put(expr);
|
|
}
|
|
|
|
class mockPhysicalPlan
|
|
{
|
|
public:
|
|
mockPhysicalPlan() {}
|
|
~mockPhysicalPlan() {}
|
|
int destory()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
DLIST_FOREACH(node, sql_expression_) {
|
|
MockSqlExpression::free(node);
|
|
}
|
|
return ret;
|
|
}
|
|
int store_sql_expresion(MockSqlExpression *sql)
|
|
{
|
|
return sql_expression_.add_last(sql);
|
|
}
|
|
private:
|
|
ObDList<MockSqlExpression> sql_expression_;
|
|
};
|
|
class ObPhyOperatorTest: public ::testing::Test
|
|
{
|
|
public:
|
|
ObPhyOperatorTest();
|
|
virtual ~ObPhyOperatorTest();
|
|
virtual void SetUp();
|
|
virtual void TearDown();
|
|
|
|
private:
|
|
// disallow copy
|
|
ObPhyOperatorTest(const ObPhyOperatorTest &other);
|
|
ObPhyOperatorTest& operator=(const ObPhyOperatorTest &other);
|
|
private:
|
|
// data members
|
|
};
|
|
ObPhyOperatorTest::ObPhyOperatorTest()
|
|
{
|
|
}
|
|
|
|
ObPhyOperatorTest::~ObPhyOperatorTest()
|
|
{
|
|
}
|
|
|
|
void ObPhyOperatorTest::SetUp()
|
|
{
|
|
}
|
|
|
|
void ObPhyOperatorTest::TearDown()
|
|
{
|
|
}
|
|
|
|
TEST_F(ObPhyOperatorTest, physical_plan_size)
|
|
{
|
|
typedef oceanbase::common::ObFixedArray<ObPhysicalPlan::ObTableVersion, common::ObIAllocator> BaseTableStore;
|
|
typedef oceanbase::common::ObFixedArray<ObPhysicalPlan::ObTableVersion, common::ObIAllocator> ViewTableStore;
|
|
typedef oceanbase::common::ObFixedArray<common::ObField, common::ObIAllocator> ParamsFieldArray;
|
|
typedef oceanbase::common::ObFixedArray<common::ObField, common::ObIAllocator> ColumnsFieldArray;
|
|
struct MockPhysicalPlan
|
|
{
|
|
common::ObArenaAllocator inner_alloc_;
|
|
common::ObArenaAllocator &allocator_;
|
|
int64_t prepare_count_;
|
|
volatile int64_t ref_count_;
|
|
int64_t schema_version_;
|
|
uint64_t plan_id_;
|
|
int64_t hint_timeout_us_;
|
|
ObPhyOperator *main_query_;
|
|
BaseTableStore table_store_;
|
|
ViewTableStore view_table_store_;
|
|
int64_t param_count_;
|
|
int64_t merged_version_;
|
|
common::ObDList<ObSqlExpression> pre_calc_exprs_;
|
|
common::ObFixedArray<ObParamInfo, common::ObIAllocator> params_info_;
|
|
uint64_t signature_;
|
|
ColumnsFieldArray field_columns_;
|
|
ParamsFieldArray param_columns_;
|
|
common::ObFixedArray<share::AutoincParam, common::ObIAllocator> autoinc_params_; //auto-incrment param
|
|
share::schema::ObStmtNeedPrivs stmt_need_privs_;
|
|
common::ObFixedArray<ObVarInfo, common::ObIAllocator> vars_;
|
|
ObPhyOperatorFactory op_factory_;
|
|
ObSqlExpressionFactory sql_expression_factory_;
|
|
ObExprOperatorFactory expr_op_factory_;
|
|
stmt::StmtType stmt_type_;
|
|
stmt::StmtType literal_stmt_type_; // 含义参考ObBasicStmt中对应定义
|
|
ObPhyPlanType plan_type_;
|
|
common::ObConsistencyLevel hint_consistency_;
|
|
uint32_t next_phy_operator_id_; //share val
|
|
// for regexp expression's compilation
|
|
int16_t regexp_op_count_;
|
|
bool is_sfu_;
|
|
bool fetch_cur_time_;
|
|
bool is_contain_virtual_table_;//为虚拟表服务，如果判断出语句中涉及虚拟表
|
|
bool is_require_sys_tenant_priv_;
|
|
//if the stmt contains user variable assignment
|
|
//such as @a:=123
|
|
//we may need to serialize the map to remote server
|
|
bool is_contains_assignment_;
|
|
bool affected_last_insert_id_; //不需要序列化远端，只在本地生成执行计划和open resultset的时候需要
|
|
bool is_affect_found_row_; //not need serialize
|
|
};
|
|
|
|
printf("output mock physical plan = %ld, ModulePageAllocator=%ld\n", sizeof(MockPhysicalPlan), sizeof(ModulePageAllocator));
|
|
ObPhysicalPlan plan;
|
|
printf("output plan size=%ld\n", sizeof(plan));
|
|
common::ObConsistencyLevel hint_consistency;
|
|
printf("output enum size = %ld\n", sizeof(hint_consistency));
|
|
common::ObDList<ObSqlExpression> sql_expression;
|
|
printf("output dlist size=%ld\n", sizeof(sql_expression));
|
|
//printf("output fixarray = %ld, IArray=%ld\n", sizeof(common::ObFixedArray), sizeof(common::ObIArray));
|
|
printf("output IArray=%ld\n", sizeof(common::ObIArray<int>));
|
|
printf("output fixarray = %ld\n", sizeof(common::ObFixedArray<int, common::ObArenaAllocator>));
|
|
printf("output physical plan size=%ld\n", sizeof(ObPhysicalPlan));
|
|
printf("output factory=%ld, sql_expression=%ld\n", sizeof(ObPhyOperatorFactory), sizeof(ObSqlExpression));
|
|
printf("output sql_factory=%ld, expr_op=%ld\n", sizeof(ObSqlExpressionFactory), sizeof(ObExprOperatorFactory));
|
|
common::ObArenaAllocator alloc;
|
|
common::ObArenaAllocator &a = alloc;
|
|
common::ObArenaAllocator *p = &alloc;
|
|
printf("output referrence =%ld, Obiallocator=%ld\n", sizeof(common::ObArenaAllocator &), sizeof(common::ObIAllocator &));
|
|
printf("output alloc =%ld, refference=%ld, point=%ld\n", sizeof(alloc), sizeof(a), sizeof(p));
|
|
printf("output pramInfo before=%ld\n", sizeof(ObParamInfo));
|
|
struct MockParamInfo
|
|
{
|
|
common::ObObjType type_;
|
|
common::ObScale scale_;
|
|
common::ObObjParam::ParamFlag flag_;
|
|
};
|
|
printf("output MockParamInfo after=%ld\n", sizeof(MockParamInfo));
|
|
printf("output ObPostItem size before=%ld, obj=%ld\n", sizeof(ObPostExprItem),sizeof(common::ObObj));
|
|
class MockPostExprItem
|
|
{
|
|
common::ObObj v1_; // const
|
|
union
|
|
{
|
|
int64_t query_id_;
|
|
int64_t cell_index_; // column reference, aka cell index in ObRow
|
|
ObExprOperator *op_; // expression operator
|
|
ObSetVar::SetScopeType sys_var_scope_;
|
|
} v2_;
|
|
common::ObAccuracy accuracy_; // for const, column, questionmark
|
|
ObItemType item_type_;
|
|
};
|
|
printf("output MockPostItem size=%ld\n", sizeof(MockPostExprItem));
|
|
printf("output ObSqlExpression size=%ld, ObPostfixExpression=%ld\n", sizeof(ObSqlExpression), sizeof(ObPostfixExpression));
|
|
printf("output ObDList size=%ld, ObNode size=%ld\n", sizeof(ObDList<int>), sizeof(ObDLinkBase<int>));
|
|
printf("output phy_operator =%ld", sizeof(ObPhyOperator));
|
|
printf("start to test tc_factory");
|
|
mockPhysicalPlan mock_plan;
|
|
MockSqlExpression *sql1 = MockSqlExpression::alloc();
|
|
MockSqlExpression *sql2 = MockSqlExpression::alloc();
|
|
EXPECT_NE(NULL, sql1);
|
|
EXPECT_NE(NULL, sql2);
|
|
EXPECT_EQ(OB_SUCCESS, mock_plan.store_sql_expresion(sql1));
|
|
EXPECT_EQ(OB_SUCCESS, mock_plan.store_sql_expresion(sql2));
|
|
mock_plan.destory();
|
|
}
|
|
int main(int argc, char **argv)
|
|
{
|
|
init_sql_factories();
|
|
::testing::InitGoogleTest(&argc,argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|