606 lines
16 KiB
C++
606 lines
16 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.
|
|
*/
|
|
|
|
#ifndef OCEANBASE_SQL_OB_SQL_DEFINE_H_
|
|
#define OCEANBASE_SQL_OB_SQL_DEFINE_H_
|
|
|
|
#include "lib/container/ob_fixed_array.h"
|
|
#include "share/datum/ob_datum.h"
|
|
#include "common/object/ob_object.h"
|
|
#include "share/ob_define.h"
|
|
|
|
namespace oceanbase
|
|
{
|
|
namespace share
|
|
{
|
|
namespace schema
|
|
{
|
|
struct ObSchemaObjVersion;
|
|
}
|
|
}
|
|
using namespace common;
|
|
namespace sql
|
|
{
|
|
const int64_t OB_SQL_MAX_CHILD_OPERATOR_NUM = 16;
|
|
const int64_t OB_MIN_PARALLEL_TASK_COUNT = 13; //期望每一个并行度最低持有的task数量
|
|
const int64_t OB_MAX_PARALLEL_TASK_COUNT = 100; //期望每一个并行度最大持有task数量
|
|
const int64_t OB_MIN_MARCO_COUNT_IN_TASK = 1; //每个task最少负责的宏块个数
|
|
const int64_t OB_INVAILD_PARALLEL_TASK_COUNT = -1;
|
|
const int64_t OB_EXPECTED_TASK_LOAD = 100; //MB, one task will get 100MB data from disk
|
|
const int64_t OB_GET_MACROS_COUNT_BY_QUERY_RANGE = 1;
|
|
const int64_t OB_GET_BLOCK_RANGE = 2;
|
|
const int64_t OB_BROADCAST_THRESHOLD = 100;
|
|
const int64_t OB_PARTITION_COUNT_PRE_SQL = 16; //用于开hash表的桶大小或者SEAarry的默认大小，假定一般SQL不会超过16个partition
|
|
const int64_t OB_MAX_RECURSIVE_SQL_LEVELS = 50; //compatible with oracle
|
|
|
|
typedef common::ObFixedArray<share::schema::ObSchemaObjVersion, common::ObIAllocator> DependenyTableStore;
|
|
typedef common::ParamStore ParamStore;
|
|
|
|
// ob_rowkey_info.h oceanbase::common::ObOrderType also defined
|
|
enum ObOrderDirection
|
|
{
|
|
NULLS_FIRST_ASC = 0, //顺序，正向扫描,Forward, NULLs first
|
|
NULLS_LAST_ASC, // 顺序，正向扫描,Forward, NULLs last
|
|
NULLS_FIRST_DESC, //倒序，反向扫描,Backward, NULLs first
|
|
NULLS_LAST_DESC, //倒序，反向扫描,Backward, NULLs last
|
|
UNORDERED, //不排序，保持现状
|
|
MAX_DIR, //非法值
|
|
};
|
|
|
|
inline bool is_null_first(ObOrderDirection order_direction) {
|
|
return NULLS_FIRST_ASC == order_direction || NULLS_FIRST_DESC == order_direction;
|
|
}
|
|
|
|
extern ObOrderDirection default_asc_direction();
|
|
extern ObOrderDirection default_desc_direction();
|
|
|
|
inline bool is_ascending_direction(const ObOrderDirection direction)
|
|
{
|
|
return (NULLS_FIRST_ASC == direction || NULLS_LAST_ASC == direction);
|
|
}
|
|
|
|
inline bool is_descending_direction(const ObOrderDirection direction)
|
|
{
|
|
return (NULLS_FIRST_DESC == direction || NULLS_LAST_DESC == direction);
|
|
}
|
|
|
|
enum ObJoinType
|
|
{
|
|
UNKNOWN_JOIN = 0,
|
|
INNER_JOIN,
|
|
LEFT_OUTER_JOIN,
|
|
RIGHT_OUTER_JOIN,
|
|
FULL_OUTER_JOIN,
|
|
LEFT_SEMI_JOIN,
|
|
RIGHT_SEMI_JOIN,
|
|
LEFT_ANTI_JOIN,
|
|
RIGHT_ANTI_JOIN,
|
|
CONNECT_BY_JOIN, //used for hierarchical query
|
|
MAX_JOIN_TYPE
|
|
};
|
|
|
|
enum SlaveMappingType {
|
|
SM_NONE = 0,
|
|
SM_PWJ_HASH_HASH,
|
|
SM_PPWJ_HASH_HASH,
|
|
SM_PPWJ_BCAST_NONE,
|
|
SM_PPWJ_NONE_BCAST,
|
|
};
|
|
|
|
enum PathType
|
|
{
|
|
INVALID = 0,
|
|
ACCESS,
|
|
JOIN,
|
|
SUBQUERY,
|
|
FAKE_CTE_TABLE_ACCESS,
|
|
FUNCTION_TABLE_ACCESS,
|
|
TEMP_TABLE_ACCESS
|
|
};
|
|
|
|
enum ObNameTypeClass
|
|
{
|
|
OB_TABLE_NAME_CLASS = 0, //table name, database names, table alias names ,affected by system variable lower_case_table_names
|
|
OB_COLUMN_NAME_CLASS = 1,// column name,column alias name. index name , stored using lettercase and comparisons are case insensitive
|
|
OB_USER_NAME_CLASS = 2,// user names, tenant names and other names, stored using lettercase and comparisons are case sensitive
|
|
};
|
|
|
|
enum ObMatchAgainstMode {
|
|
NATURAL_LANGUAGE_MODE = 0,
|
|
BOOLEAN_MODE = 1
|
|
};
|
|
|
|
#define IS_JOIN(type) \
|
|
(((type) == PHY_MERGE_JOIN) || \
|
|
((type) == PHY_NESTED_LOOP_JOIN) || \
|
|
((type) == PHY_HASH_JOIN) || \
|
|
((type) == PHY_BLOCK_BASED_NESTED_LOOP_JOIN))
|
|
|
|
#define IS_OUTER_JOIN(join_type) \
|
|
((join_type) == LEFT_OUTER_JOIN || \
|
|
(join_type) == RIGHT_OUTER_JOIN || \
|
|
(join_type) == FULL_OUTER_JOIN)
|
|
|
|
#define IS_SEMI_ANTI_JOIN(join_type) \
|
|
((join_type) == LEFT_SEMI_JOIN || \
|
|
(join_type) == RIGHT_SEMI_JOIN || \
|
|
(join_type) == LEFT_ANTI_JOIN || \
|
|
(join_type) == RIGHT_ANTI_JOIN)
|
|
|
|
#define IS_SEMI_JOIN(join_type) \
|
|
((join_type) == LEFT_SEMI_JOIN || \
|
|
(join_type) == RIGHT_SEMI_JOIN)
|
|
|
|
#define IS_ANTI_JOIN(join_type) \
|
|
((join_type) == LEFT_ANTI_JOIN || \
|
|
(join_type) == RIGHT_ANTI_JOIN)
|
|
|
|
#define IS_LEFT_SEMI_ANTI_JOIN(join_type) \
|
|
((join_type) == LEFT_SEMI_JOIN || \
|
|
(join_type) == LEFT_ANTI_JOIN)
|
|
|
|
#define IS_RIGHT_SEMI_ANTI_JOIN(join_type) \
|
|
((join_type) == RIGHT_SEMI_JOIN || \
|
|
(join_type) == RIGHT_ANTI_JOIN)
|
|
|
|
#define IS_OUTER_OR_CONNECT_BY_JOIN(join_type) (IS_OUTER_JOIN(join_type) || CONNECT_BY_JOIN == join_type)
|
|
|
|
#define IS_DUMMY_PHY_OPERATOR(op_type) ((op_type == PHY_MONITORING_DUMP))
|
|
|
|
#define IS_LEFT_STYLE_JOIN(join_type) \
|
|
((join_type) == LEFT_SEMI_JOIN || \
|
|
(join_type) == LEFT_ANTI_JOIN || \
|
|
(join_type) == LEFT_OUTER_JOIN || \
|
|
(join_type) == FULL_OUTER_JOIN)
|
|
|
|
#define IS_RIGHT_STYLE_JOIN(join_type) \
|
|
((join_type) == RIGHT_SEMI_JOIN || \
|
|
(join_type) == RIGHT_ANTI_JOIN || \
|
|
(join_type) == RIGHT_OUTER_JOIN || \
|
|
(join_type) == FULL_OUTER_JOIN)
|
|
|
|
#define IS_SET_PHY_OP(type) \
|
|
(((type) == PHY_MERGE_UNION) || \
|
|
((type) == PHY_HASH_UNION) || \
|
|
((type) == PHY_HASH_INTERSECT) || \
|
|
((type) == PHY_MERGE_INTERSECT) || \
|
|
((type) == PHY_HASH_EXCEPT) || \
|
|
((type) == PHY_MERGE_EXCEPT))
|
|
|
|
|
|
inline ObJoinType get_opposite_join_type(ObJoinType type)
|
|
{
|
|
ObJoinType oppo_type = UNKNOWN_JOIN;
|
|
switch (type) {
|
|
case INNER_JOIN:
|
|
oppo_type = INNER_JOIN;
|
|
break;
|
|
case LEFT_OUTER_JOIN:
|
|
oppo_type = RIGHT_OUTER_JOIN;
|
|
break;
|
|
case RIGHT_OUTER_JOIN:
|
|
oppo_type = LEFT_OUTER_JOIN;
|
|
break;
|
|
case FULL_OUTER_JOIN:
|
|
oppo_type = FULL_OUTER_JOIN;
|
|
break;
|
|
case LEFT_SEMI_JOIN:
|
|
oppo_type = RIGHT_SEMI_JOIN;
|
|
break;
|
|
case RIGHT_SEMI_JOIN:
|
|
oppo_type = LEFT_SEMI_JOIN;
|
|
break;
|
|
case LEFT_ANTI_JOIN:
|
|
oppo_type = RIGHT_ANTI_JOIN;
|
|
break;
|
|
case RIGHT_ANTI_JOIN:
|
|
oppo_type = LEFT_ANTI_JOIN;
|
|
break;
|
|
case CONNECT_BY_JOIN:
|
|
oppo_type = CONNECT_BY_JOIN;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return oppo_type;
|
|
}
|
|
|
|
inline const ObString &ob_join_type_str(ObJoinType join_type)
|
|
{
|
|
static const ObString join_type_str_st[] =
|
|
{
|
|
"UNKNOWN JOIN",
|
|
"JOIN",
|
|
"OUTER JOIN",
|
|
"RIGHT OUTER JOIN",
|
|
"FULL OUTER JOIN",
|
|
"SEMI JOIN",
|
|
"RIGHT SEMI JOIN",
|
|
"ANTI JOIN",
|
|
"RIGHT ANTI JOIN",
|
|
"CONNECT BY"
|
|
};
|
|
|
|
if (OB_LIKELY(join_type >= UNKNOWN_JOIN) && OB_LIKELY(join_type <= CONNECT_BY_JOIN)) {
|
|
return join_type_str_st[join_type];
|
|
} else {
|
|
return join_type_str_st[0];
|
|
}
|
|
}
|
|
|
|
enum ObTableLocationType
|
|
{
|
|
OB_TBL_LOCATION_UNINITIALIZED = 0,
|
|
OB_TBL_LOCATION_LOCAL,
|
|
OB_TBL_LOCATION_REMOTE,
|
|
OB_TBL_LOCATION_DISTRIBUTED,
|
|
OB_TBL_LOCATION_ALL//like EXPRESSION, match all
|
|
};
|
|
|
|
enum ObRepartitionType
|
|
{
|
|
OB_REPARTITION_NO_REPARTITION = 0,//不重分区
|
|
OB_REPARTITION_ONE_SIDE_ONE_LEVEL,//只有一边按照一级分区做repartiton,不repartition的一边是一级分区
|
|
OB_REPARTITION_ONE_SIDE_TWO_LEVEL,//只有一边按照二级分区做repartiton, 不repartition的一边是二级分区
|
|
OB_REPARTITION_BOTH_SIDE_ONE_LEVEL,//两边都按照一级分区方式做repartition, 分区键是连接键
|
|
OB_REPARTITION_ONE_SIDE_ONE_LEVEL_FIRST,//只有一边按照另外一边(二级分区表)的一级分区做repartiton
|
|
OB_REPARTITION_ONE_SIDE_ONE_LEVEL_SUB,//只有一边按照另外一边(二级分区)的二级分区做repartiton
|
|
};
|
|
|
|
enum ObRepartitionScope
|
|
{
|
|
OB_REPARTITION_NONE_SIDE = 0,
|
|
OB_REPARTITION_LEFT_SIDE,
|
|
OB_REPARTITION_RIGHT_SIDE,
|
|
OB_REPARTITION_BOTH_SIDE,
|
|
};
|
|
|
|
enum ObPhyPlanType
|
|
{
|
|
OB_PHY_PLAN_UNINITIALIZED = 0,
|
|
OB_PHY_PLAN_LOCAL,
|
|
OB_PHY_PLAN_REMOTE,
|
|
OB_PHY_PLAN_DISTRIBUTED,
|
|
OB_PHY_PLAN_UNCERTAIN
|
|
};
|
|
|
|
inline const ObString &ob_plan_type_str(ObPhyPlanType plan_type)
|
|
{
|
|
static const ObString plan_type_str_st[] =
|
|
{
|
|
"UNINITIALIZED",
|
|
"LOCAL",
|
|
"REMOTE",
|
|
"DISTRIBUTED",
|
|
};
|
|
|
|
if (OB_LIKELY(plan_type >= OB_PHY_PLAN_UNINITIALIZED)
|
|
&& OB_LIKELY(plan_type <= OB_PHY_PLAN_DISTRIBUTED)) {
|
|
return plan_type_str_st[plan_type];
|
|
} else {
|
|
return plan_type_str_st[0];
|
|
}
|
|
}
|
|
|
|
enum ExplainType
|
|
{
|
|
EXPLAIN_UNINITIALIZED = 0,
|
|
EXPLAIN_OUTLINE,
|
|
EXPLAIN_EXTENDED,
|
|
EXPLAIN_PARTITIONS,
|
|
EXPLAIN_TRADITIONAL,
|
|
EXPLAIN_FORMAT_JSON,
|
|
EXPLAIN_BASIC,
|
|
EXPLAIN_PLANREGRESS,
|
|
EXPLAIN_EXTENDED_NOADDR,
|
|
EXPLAIN_DBLINK_STMT,
|
|
EXPLAIN_HINT_FORMAT,
|
|
};
|
|
|
|
enum DiagnosticsType
|
|
{
|
|
DIAGNOSTICS_UNINITIALIZED = 0,
|
|
GET_CURRENT_COND,
|
|
GET_CURRENT_INFO,
|
|
GET_STACKED_COND,
|
|
GET_STACKED_INFO
|
|
};
|
|
|
|
enum OutlineType
|
|
{
|
|
OUTLINE_TYPE_UNINIT = 0,
|
|
USED_HINT,
|
|
OUTLINE_DATA
|
|
};
|
|
|
|
enum ObPlanLocationType
|
|
{
|
|
UNINITIALIZED = 0,
|
|
LOCAL,
|
|
REMOTE,
|
|
DISTRIBUTED
|
|
};
|
|
|
|
struct ObPQDistributeMethod
|
|
{
|
|
#define PQ_DIST_METHOD_DEF(DEF) \
|
|
DEF(NONE,) \
|
|
DEF(PARTITION,) \
|
|
DEF(RANDOM,) \
|
|
DEF(RANDOM_LOCAL,) \
|
|
DEF(HASH,) \
|
|
DEF(BROADCAST,) \
|
|
\
|
|
/* distribute in two level: SQC && PX worker*/ \
|
|
/* BROADCAST for SQC, RANDOM for PX worker */ \
|
|
DEF(BC2HOST,) \
|
|
DEF(SM_BROADCAST,) \
|
|
DEF(PARTITION_HASH,) \
|
|
DEF(DROP,) \
|
|
/*PARTITION_RANDOM：PDML情况下处理分区表分区内并行；数据按照partition所在的SQC进行划分，*/ \
|
|
/*并行度不受partition个数的限制；但是PARTITION对应的pkey分区，分区粒度为partition，*/ \
|
|
/*实际并行度受partition的个数限制，无法在PDML场景下充分利用并行*/ \
|
|
DEF(PARTITION_RANDOM,) \
|
|
DEF(RANGE,)\
|
|
DEF(PARTITION_RANGE,)\
|
|
DEF(LOCAL,) // represents pull to local
|
|
|
|
DECLARE_ENUM(Type, type, PQ_DIST_METHOD_DEF, static);
|
|
|
|
static ObPQDistributeMethod::Type get_print_dist(ObPQDistributeMethod::Type method) {
|
|
ObPQDistributeMethod::Type print_method = ObPQDistributeMethod::LOCAL;
|
|
if (ObPQDistributeMethod::Type::SM_BROADCAST == method) {
|
|
print_method = ObPQDistributeMethod::Type::BROADCAST;
|
|
} else if (ObPQDistributeMethod::Type::PARTITION_HASH == method) {
|
|
print_method = ObPQDistributeMethod::Type::PARTITION;
|
|
} else {
|
|
print_method = method;
|
|
}
|
|
return print_method;
|
|
}
|
|
};
|
|
|
|
struct ObNullDistributeMethod
|
|
{
|
|
/*
|
|
* ObNullDistributeMethod::NONE - neither DROP nor RANDOM, do null distribution as ObSliceCalc said
|
|
*/
|
|
#define NULL_DIST_METHOD_DEF(DEF) \
|
|
DEF(NONE,) \
|
|
DEF(DROP,) \
|
|
DEF(RANDOM,)
|
|
|
|
DECLARE_ENUM(Type, type, NULL_DIST_METHOD_DEF, static);
|
|
static ObNullDistributeMethod::Type get_print_dist(ObNullDistributeMethod::Type method) {
|
|
return method;
|
|
}
|
|
};
|
|
|
|
enum PartitionFilterType {
|
|
Uninitialized,
|
|
Forbidden,
|
|
OneLevelPartitionKey,
|
|
TwoLevelPartitionKey,
|
|
WholePartitionKey,
|
|
};
|
|
|
|
enum DistinctType
|
|
{
|
|
T_DISTINCT_NONE = 0,
|
|
T_HASH_DISTINCT = 1,
|
|
T_MERGE_DISTINCT = 2
|
|
};
|
|
|
|
enum class ObPDMLOption {
|
|
NOT_SPECIFIED = -1,
|
|
ENABLE,
|
|
DISABLE,
|
|
MAX_VALUE
|
|
};
|
|
|
|
enum OrderingFlag
|
|
{
|
|
NOT_MATCH = 0,
|
|
JOIN_MATCH = 1,
|
|
GROUP_MATCH = 1 << 1,
|
|
WINFUNC_MATCH = 1 << 2,
|
|
DISTINCT_MATCH = 1 << 3,
|
|
SET_MATCH = 1 << 4,
|
|
ORDERBY_MATCH = 1 << 5,
|
|
POTENTIAL_MATCH = 1 << 6 // ordering可能在subplan scan后用到
|
|
};
|
|
|
|
enum OrderingCheckScope
|
|
{
|
|
NOT_CHECK = 0,
|
|
CHECK_GROUP = 1,
|
|
CHECK_WINFUNC = 1 << 1,
|
|
CHECK_DISTINCT = 1 << 2,
|
|
CHECK_SET = 1 << 3,
|
|
CHECK_ORDERBY = 1 << 4,
|
|
CHECK_ALL = (1 << 5) - 1
|
|
};
|
|
|
|
|
|
enum ObExecuteMode
|
|
{
|
|
EXECUTE_INVALID = 0,
|
|
EXECUTE_INNER,
|
|
EXECUTE_LOCAL,
|
|
EXECUTE_REMOTE,
|
|
EXECUTE_DIST,
|
|
EXECUTE_PS_PREPARE,//prepare statement local server
|
|
EXECUTE_PS_EXECUTE,//prepare statement local server
|
|
EXECUTE_PS_FETCH,
|
|
EXECUTE_PS_SEND_PIECE,
|
|
EXECUTE_PS_GET_PIECE,
|
|
EXECUTE_PS_SEND_LONG_DATA
|
|
};
|
|
|
|
|
|
enum PartitionIdCalcType {
|
|
CALC_INVALID = -1, // invalid calc type
|
|
CALC_NORMAL = 0, // calc both part id and subpart id
|
|
CALC_IGNORE_FIRST_PART = 1, // only calc subpart id
|
|
CALC_IGNORE_SUB_PART =2 // only calc part id
|
|
};
|
|
|
|
enum class ObParamOption {
|
|
NOT_SPECIFIED = -1,
|
|
FORCE,
|
|
EXACT,
|
|
MAX_VALUE
|
|
};
|
|
|
|
struct ObSqlArrayObj
|
|
{
|
|
ObSqlArrayObj()
|
|
: data_(nullptr),
|
|
count_(0),
|
|
element_()
|
|
{
|
|
}
|
|
typedef common::ObArrayWrap<common::ObObj> DataArray;
|
|
static ObSqlArrayObj *alloc(common::ObIAllocator &allocator, int64_t count);
|
|
TO_STRING_KV("data", DataArray(data_, count_),
|
|
K_(count),
|
|
K_(element));
|
|
common::ObObjParam *data_;
|
|
// ObObjParam *data_1_;
|
|
int64_t count_;
|
|
common::ObDataType element_;
|
|
};
|
|
|
|
enum DominateRelation
|
|
{
|
|
OBJ_LEFT_DOMINATE = 0,
|
|
OBJ_RIGHT_DOMINATE,
|
|
OBJ_EQUAL,
|
|
OBJ_UNCOMPARABLE
|
|
};
|
|
|
|
// for parallel precedence, refer to
|
|
// https://docs.oracle.com/cd/E11882_01/server.112/e41573/hintsref.htm#PFGRF94937
|
|
enum PXParallelRule
|
|
{
|
|
NOT_USE_PX = 0, // Plan执行不使用PX框架
|
|
USE_PX_DEFAULT, // Plan执行使用PX框架，使用默认方式
|
|
MANUAL_HINT, // /*+ parallel(3) */
|
|
MANUAL_TABLE_HINT, // /*+ parallel(t1 3) */
|
|
SESSION_FORCE_PARALLEL, // alter session force parallel query parallel 3;
|
|
MANUAL_TABLE_DOP, // create table t1 (...) parallel 3;
|
|
MAX_OPTION
|
|
};
|
|
|
|
inline const char *ob_px_parallel_rule_str(PXParallelRule px_parallel_ruel)
|
|
{
|
|
const char *ret = "NOT_USE_PX";
|
|
static const char *parallel_rule_type_to_str[] =
|
|
{
|
|
"NOT_USE_PX",
|
|
"USE_PX_DEFAULT",
|
|
"MANUAL_HINT",
|
|
"MANUAL_TABLE_HINT",
|
|
"SESSION_FORCE_PARALLEL",
|
|
"MANUAL_TABLE_DOP",
|
|
"MAX_OPTION",
|
|
};
|
|
if (OB_LIKELY(px_parallel_ruel >= NOT_USE_PX)
|
|
&& OB_LIKELY(px_parallel_ruel <= MAX_OPTION)) {
|
|
ret = parallel_rule_type_to_str[px_parallel_ruel];
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
typedef common::ObDmlEventType ObDmlEventType;
|
|
|
|
enum MayAddIntervalPart {
|
|
NO, // do nothing, just set part id to 0
|
|
YES, // add an interval partition, and set err code to force retry
|
|
PART_CHANGE_ERR, // set err code, make query stop and report and error msg to client
|
|
};
|
|
|
|
enum ObIDPAbortType
|
|
{
|
|
IDP_DEFAULT_ABORT = -1,
|
|
IDP_INVALID_HINT_ABORT = 0,
|
|
IDP_STOPENUM_EXPDOWN_ABORT = 1,
|
|
IDP_STOPENUM_LINEARDOWN_ABORT = 2,
|
|
IDP_ENUM_FAILED_ABORT = 3,
|
|
IDP_NO_ABORT = 4
|
|
};
|
|
|
|
OB_INLINE ObSqlArrayObj *ObSqlArrayObj::alloc(common::ObIAllocator &allocator, int64_t count)
|
|
{
|
|
ObSqlArrayObj *array_obj = nullptr;
|
|
void *array_buf = nullptr;
|
|
void *data_buf = nullptr;
|
|
int64_t array_size = sizeof(ObSqlArrayObj) + sizeof(common::ObObjParam) * count;
|
|
if (OB_NOT_NULL(array_buf = allocator.alloc(array_size))) {
|
|
array_obj = new (array_buf) ObSqlArrayObj();
|
|
data_buf = static_cast<char*>(array_buf) + sizeof(ObSqlArrayObj);
|
|
array_obj->data_ = new (data_buf) common::ObObjParam[count];
|
|
array_obj->count_ = count;
|
|
}
|
|
return array_obj;
|
|
}
|
|
|
|
struct ObSqlDatumArray
|
|
{
|
|
ObSqlDatumArray()
|
|
: data_(nullptr),
|
|
count_(0),
|
|
element_()
|
|
{
|
|
}
|
|
typedef common::ObArrayWrap<common::ObDatum> DatumArray;
|
|
static ObSqlDatumArray *alloc(common::ObIAllocator &allocator, int64_t count);
|
|
TO_STRING_KV("data", DatumArray(data_, count_),
|
|
K_(count),
|
|
K_(element));
|
|
common::ObDatum *data_;
|
|
int64_t count_;
|
|
common::ObDataType element_;
|
|
};
|
|
|
|
OB_INLINE ObSqlDatumArray *ObSqlDatumArray::alloc(common::ObIAllocator &allocator, int64_t count)
|
|
{
|
|
ObSqlDatumArray *array_obj = nullptr;
|
|
void *array_buf = nullptr;
|
|
void *data_buf = nullptr;
|
|
int64_t array_size = sizeof(ObSqlDatumArray) + sizeof(common::ObDatum) * count;
|
|
if (OB_NOT_NULL(array_buf = allocator.alloc(array_size))) {
|
|
array_obj = new (array_buf) ObSqlDatumArray();
|
|
data_buf = static_cast<char*>(array_buf) + sizeof(ObSqlDatumArray);
|
|
array_obj->data_ = new (data_buf) common::ObDatum[count];
|
|
array_obj->count_ = count;
|
|
}
|
|
return array_obj;
|
|
}
|
|
|
|
// Window function optimization settings. (_windowfunc_optimization_settings sys variable)
|
|
struct ObWinfuncOptimizationOpt
|
|
{
|
|
ObWinfuncOptimizationOpt() : v_(0) {}
|
|
union {
|
|
struct {
|
|
uint64_t disable_range_distribution_:1;
|
|
// add more options here.
|
|
};
|
|
uint64_t v_;
|
|
};
|
|
};
|
|
|
|
} // namespace sql
|
|
} // namespace oceanbase
|
|
#endif /* OCEANBASE_SQL_OB_SQL_DEFINE_H_ */
|