/**

* 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"

namespace oceanbase {

namespace share {

namespace schema {

struct ObSchemaObjVersion;

}

} // namespace share

namespace sql {

const int64_t OB_SQL_MAX_CHILD_OPERATOR_NUM = 16;

const int64_t OB_MIN_PARALLEL_TASK_COUNT = 13; // min task count for one worker

const int64_t OB_MAX_PARALLEL_TASK_COUNT = 100; // max task count for one worker

const int64_t OB_MIN_MARCO_COUNT_IN_TASK = 1; // min macro blocks for one worker

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;

typedef common::ObFixedArray<share::schema::ObSchemaObjVersion, common::ObIAllocator> DependenyTableStore;

// 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, // no order

MAX_DIR, // invalid

};

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 char* ob_join_type_str(ObJoinType join_type)

{

const char* ret = "UNKNOWN TYPE";

static const char* 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)) {

ret = join_type_str_st[join_type];

}

return ret;

}

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, // no partition

OB_REPARTITION_ONE_SIDE_ONE_LEVEL, // none partition and one level partition

OB_REPARTITION_ONE_SIDE_TWO_LEVEL, // none partition and two level partition

OB_REPARTITION_BOTH_SIDE_ONE_LEVEL, // both one level partition

OB_REPARTITION_ONE_SIDE_ONE_LEVEL_FIRST, // repartition by first level partition of two level partition

OB_REPARTITION_ONE_SIDE_ONE_LEVEL_SUB, // repartition by second level partition of two level partition

};

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 char* ob_plan_type_str(ObPhyPlanType plan_type)

{

const char* ret = "UNKNOWN TYPE";

static const char* 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)) {

ret = plan_type_str_st[plan_type];

}

return ret;

}

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,

};

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, ) \

DEF(PARTITION_RANDOM, ) \

DEF(MAX_VALUE, ) // 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::MAX_VALUE;

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 ObUsePxHint {

#define USE_PX_METHOD_DEF(DEF) \

DEF(DISABLE, ) \

DEF(ENABLE, ) \

DEF(NOT_SET, ) \

DEF(INVALID, ) \

DEF(MAX_VALUE, )

DECLARE_ENUM(Type, type, USE_PX_METHOD_DEF, static);

};

struct ObUseRewriteHint {

#define USE_REWRITE_DEF(DEF) \

DEF(NOT_SET, ) \

DEF(NO_EXPAND, ) \

DEF(USE_CONCAT, ) \

DEF(V_MERGE, ) \

DEF(NO_V_MERGE, ) \

DEF(UNNEST, ) \

DEF(NO_UNNEST, ) \

DEF(PLACE_GROUPBY, ) \

DEF(NO_PLACE_GROUPBY, ) \

DEF(NO_PRED_DEDUCE, ) \

DEF(MAX_VALUE, )

DECLARE_ENUM(Type, type, USE_REWRITE_DEF, static);

};

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

};

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,

};

enum PartitionIdCalcType {

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

};

} // namespace sql

} // namespace oceanbase

#endif /* OCEANBASE_SQL_OB_SQL_DEFINE_H_ */