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

reformat source code

Browse Source 
according to code styles, 'AccessModifierOffset' should be -2.
This commit is contained in:
gm
2021-06-16 15:48:42 +08:00
committed by MizuhaHimuraki
parent 8c4a2f26a6
commit 4a92b6d7df
3314 changed files with 23131 additions and 23401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/sql/resolver/expr/ob_case_op_expr.h
View File

@ -20,7 +20,7 @@ namespace jit {
namespace expr {
class ObCaseOpExpr : virtual public ObExpr {
public:
public:
ObCaseOpExpr()
{
set_expr_class(EXPR_CASE_OPERATOR);

4
src/sql/resolver/expr/ob_column_index_provider.h
View File

@ -20,7 +20,7 @@ namespace jit {
namespace expr {
class ObColumnIndexProvider {
public:
public:
ObColumnIndexProvider()
{}
/**
@ -33,7 +33,7 @@ class ObColumnIndexProvider {
*/
virtual int get_idx(const ObExpr* raw_expr, int64_t& index) const = 0;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObColumnIndexProvider);
};

2
src/sql/resolver/expr/ob_column_ref_expr.h
View File

@ -20,7 +20,7 @@ namespace jit {
namespace expr {
class ObColumnRefExpr : virtual public ObExpr {
public:
public:
ObColumnRefExpr(ObItemType expr_type = T_INVALID) : ObExpr(expr_type)
{
set_expr_class(EXPR_COLUMN_REF);

4
src/sql/resolver/expr/ob_const_expr.h
View File

@ -23,7 +23,7 @@ namespace expr {
// OceanBase constant expression.
class ObConstExpr : virtual public ObExpr {
public:
public:
ObConstExpr()
{
set_expr_class(EXPR_CONST);
@ -34,7 +34,7 @@ class ObConstExpr : virtual public ObExpr {
common::ObObj& get_value();
const common::ObObj& get_value() const;
protected:
protected:
common::ObObj value_;
};

4
src/sql/resolver/expr/ob_expr.h
View File

@ -27,7 +27,7 @@ class ObExpr;
typedef ::oceanbase::common::ObSEArray<ObExpr*, 2> ExprArray;
// The interface of OceanBase raw expression structure.
class ObExpr {
public:
public:
enum ExprClass {
EXPR_INVALID_CLASS = 0,
EXPR_CONST,
@ -167,7 +167,7 @@ class ObExpr {
TO_STRING_KV(K_(type), K_(expr_class));
protected:
protected:
ObItemType type_;
ExprClass expr_class_;
sql::ObExprResType result_type_;

6
src/sql/resolver/expr/ob_expr_relation_analyzer.h
View File

@ -20,16 +20,16 @@ class ObRawExpr;
class ObDMLStmt;
class ObQueryRefRawExpr;
class ObExprRelationAnalyzer {
public:
public:
explicit ObExprRelationAnalyzer();
int pull_expr_relation_id_and_levels(ObRawExpr* expr, int32_t cur_stmt_level);
private:
private:
int init_expr_info(ObRawExpr& expr);
int visit_expr(ObRawExpr& expr, int32_t stmt_level);
int visit_stmt(ObDMLStmt* stmt);
private:
private:
// auto_free = false, only used in function stack
common::ObSEArray<ObQueryRefRawExpr*, common::OB_MAX_SUBQUERY_LAYER_NUM> query_exprs_;
};

4
src/sql/resolver/expr/ob_expr_visitor.h
View File

@ -25,7 +25,7 @@ class ObCaseOpExpr;
class ObColumnRefExpr;
class ObExprVisitor {
public:
public:
virtual int visit(const ObExpr& expr) = 0;
virtual int visit(const ObConstExpr& expr) = 0;
virtual int visit(const ObVarExpr& expr) = 0;
@ -33,7 +33,7 @@ class ObExprVisitor {
virtual int visit(const ObColumnRefExpr& expr) = 0;
virtual int visit(const ObCaseOpExpr& expr) = 0;
protected:
protected:
bool skip_;
};

4
src/sql/resolver/expr/ob_op_expr.h
View File

@ -20,7 +20,7 @@ namespace jit {
namespace expr {
class ObOpExpr : virtual public ObExpr {
public:
public:
ObOpExpr()
{
set_expr_class(EXPR_OPERATOR);
@ -40,7 +40,7 @@ class ObOpExpr : virtual public ObExpr {
return common::OB_NOT_SUPPORTED;
};
private:
private:
};
} // namespace expr

158
src/sql/resolver/expr/ob_raw_expr.h
View File

@ -57,7 +57,7 @@ extern ObRawExpr* USELESS_POINTER;
const static int64_t DEFAULT_SQL_BITSET_SIZE = 32;
template <int64_t N = DEFAULT_SQL_BITSET_SIZE, typename FlagType = int64_t, bool auto_free = false>
class ObSqlBitSet {
public:
public:
typedef uint32_t BitSetWord;
ObSqlBitSet() : block_allocator_(NULL), bit_set_word_array_(NULL), desc_()
@ -663,7 +663,7 @@ class ObSqlBitSet {
return *this;
}
private:
private:
int alloc_new_buf(int64_t word_cnt)
{
int ret = OB_SUCCESS;
@ -720,7 +720,7 @@ class ObSqlBitSet {
return ret;
}
private:
private:
static const int64_t PER_BITSETWORD_BITS = 32;
static const int64_t PER_BITSETWORD_MOD_BITS = 5;
static const int64_t PER_BITSETWORD_MASK = PER_BITSETWORD_BITS - 1;
@ -735,7 +735,7 @@ class ObSqlBitSet {
{}
};
private:
private:
ObIAllocator* block_allocator_;
BitSetWord* bit_set_word_array_;
SqlBitSetDesc desc_;
@ -762,7 +762,7 @@ enum AccessNameType {
class ObRawExpr;
class ObSysFunRawExpr;
class ObObjAccessIdent {
public:
public:
ObObjAccessIdent()
: type_(UNKNOWN), access_name_(), access_index_(common::OB_INVALID_INDEX), sys_func_expr_(NULL), params_()
{}
@ -786,7 +786,7 @@ class ObObjAccessIdent {
return *this;
}
public:
public:
inline void set_type(AccessNameType type)
{
type_ = type;
@ -863,7 +863,7 @@ class ObObjAccessIdent {
class ObColumnRefRawExpr;
class ObQualifiedName {
public:
public:
ObQualifiedName()
: database_name_(),
tbl_name_(),
@ -915,7 +915,7 @@ class ObQualifiedName {
TO_STRING_KV(N_DATABASE_NAME, database_name_, N_TABLE_NAME, tbl_name_, N_COLUMN, col_name_, K_(is_star), K_(ref_expr),
K_(parents_expr_info), K_(parent_aggr_level), K_(access_idents), K_(is_access_root));
public:
public:
common::ObString database_name_;
common::ObString tbl_name_; // used for package name for UDF
common::ObString col_name_; // used for function name for UDF
@ -959,7 +959,7 @@ struct OrderItem {
OrderItem(ObRawExpr* expr, ObOrderDirection order_type) : expr_(expr), order_type_(order_type)
{}
public:
public:
virtual ~OrderItem()
{}
void reset()
@ -1107,7 +1107,7 @@ enum ObVarType {
struct ObVarInfo final {
OB_UNIS_VERSION(1);
public:
public:
ObVarInfo() : type_(INVALID_VAR), name_()
{}
int deep_copy(common::ObIAllocator& allocator, ObVarInfo& var_info) const;
@ -1209,7 +1209,7 @@ class ObRawExprVisitor;
struct ObHiddenColumnItem;
class ObRawExpr : virtual public jit::expr::ObExpr {
public:
public:
friend sql::ObExpr* ObStaticEngineExprCG::get_rt_expr(const ObRawExpr& raw_expr);
friend sql::ObExpr* ObExprOperator::get_rt_expr(const ObRawExpr& raw_expr) const;
@ -1487,14 +1487,14 @@ class ObRawExpr : virtual public jit::expr::ObExpr {
K_(expr_level), K_(expr_levels), K_(enum_set_values), K_(is_explicited_reference), K_(ref_count),
K_(is_for_generated_column), K_(extra), K_(is_calculated));
public:
public:
uint32_t magic_num_;
protected:
protected:
static const int64_t COMMON_MULTI_NUM = 16;
static const int64_t COMMON_ENUM_SET_VALUE_NUM = 4;
protected:
protected:
ObExprInfo info_; // flags
ObRelIds rel_ids_; // related table idx
// means the raw expr contain which level variables(column, aggregate expr, set expr or subquery expr)
@ -1515,7 +1515,7 @@ class ObRawExpr : virtual public jit::expr::ObExpr {
ObRawExpr* orig_expr_; // orig raw expr before pre cast of pre calc.
bool is_calculated_; // for code gerenation in static engine.
bool is_deterministic_; // expr is deterministic, given the same inputs, returns the same result
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObRawExpr);
};
@ -1619,7 +1619,7 @@ inline const ObRelIds& ObRawExpr::get_relation_ids() const
////////////////////////////////////////////////////////////////
class ObTerminalRawExpr : public ObRawExpr {
public:
public:
explicit ObTerminalRawExpr(ObItemType expr_type = T_INVALID) : ObRawExpr(expr_type)
{}
explicit ObTerminalRawExpr(common::ObIAllocator& alloc, ObItemType expr_type = T_INVALID)
@ -1645,14 +1645,14 @@ class ObTerminalRawExpr : public ObRawExpr {
return seed;
}
protected:
private:
protected:
private:
DISALLOW_COPY_AND_ASSIGN(ObTerminalRawExpr);
};
////////////////////////////////////////////////////////////////
class ObConstRawExpr : public ObTerminalRawExpr, public jit::expr::ObConstExpr {
public:
public:
ObConstRawExpr() : is_date_unit_(false) /*: precalc_expr_(NULL)*/
{
ObExpr::set_expr_class(ObExpr::EXPR_CONST);
@ -1705,18 +1705,18 @@ class ObConstRawExpr : public ObTerminalRawExpr, public jit::expr::ObConstExpr {
int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const;
DECLARE_VIRTUAL_TO_STRING;
private:
private:
common::ObString literal_prefix_; // used in compile phase.
common::ObObjMeta obj_meta_;
bool is_date_unit_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObConstRawExpr);
};
////////////////////////////////////////////////////////////////
class ObVarRawExpr : public ObTerminalRawExpr, public jit::expr::ObVarExpr {
public:
public:
ObVarRawExpr()
{
ObExpr::set_expr_class(ObExpr::EXPR_VAR);
@ -1754,14 +1754,14 @@ class ObVarRawExpr : public ObTerminalRawExpr, public jit::expr::ObVarExpr {
return result_type_assigned_;
}
private:
private:
bool result_type_assigned_;
DISALLOW_COPY_AND_ASSIGN(ObVarRawExpr);
};
////////////////////////////////////////////////////////////////
class ObUserVarIdentRawExpr : public ObConstRawExpr {
public:
public:
ObUserVarIdentRawExpr() : is_contain_assign_(false), query_has_udf_(false)
{}
ObUserVarIdentRawExpr(common::ObIAllocator& alloc)
@ -1804,18 +1804,18 @@ class ObUserVarIdentRawExpr : public ObConstRawExpr {
bool is_same_variable(const ObObj& obj) const;
DECLARE_VIRTUAL_TO_STRING;
private:
private:
bool is_contain_assign_;
bool query_has_udf_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObUserVarIdentRawExpr);
};
////////////////////////////////////////////////////////////////
class ObLogicalOperator;
class ObQueryRefRawExpr : public ObTerminalRawExpr {
public:
public:
ObQueryRefRawExpr()
: ObTerminalRawExpr(),
ref_id_(common::OB_INVALID_ID),
@ -1934,7 +1934,7 @@ class ObQueryRefRawExpr : public ObTerminalRawExpr {
ref_id_, K_(expr_level), K_(expr_levels), K_(output_column), K_(is_set), K_(is_cursor), K_(column_types),
K_(enum_set_values));
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObQueryRefRawExpr);
int64_t ref_id_;
union {
@ -1970,7 +1970,7 @@ inline int64_t ObQueryRefRawExpr::get_output_column() const
////////////////////////////////////////////////////////////////
class ObColumnRefRawExpr : public ObTerminalRawExpr, public jit::expr::ObColumnRefExpr {
public:
public:
ObColumnRefRawExpr()
: ObExpr(),
ObTerminalRawExpr(),
@ -2210,7 +2210,7 @@ class ObColumnRefRawExpr : public ObTerminalRawExpr, public jit::expr::ObColumnR
K_(column_name), K_(expr_level), K_(expr_levels), K_(column_flags), K_(enum_set_values), K_(is_lob_column),
K_(is_unpivot_mocked_column), K_(is_hidden));
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObColumnRefRawExpr);
uint64_t table_id_;
uint64_t column_id_;
@ -2260,7 +2260,7 @@ inline uint64_t& ObColumnRefRawExpr::get_column_id()
////////////////////////////////////////////////////////////////
class ObSetOpRawExpr : public ObTerminalRawExpr {
public:
public:
ObSetOpRawExpr() : ObTerminalRawExpr(), idx_(-1)
{
set_expr_class(ObExpr::EXPR_SET_OP);
@ -2293,14 +2293,14 @@ class ObSetOpRawExpr : public ObTerminalRawExpr {
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_,
K_(expr_level), K_(expr_levels), K_(idx));
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObSetOpRawExpr);
int64_t idx_;
};
////////////////////////////////////////////////////////////////
class ObAliasRefRawExpr : public ObRawExpr {
public:
public:
ObAliasRefRawExpr() : ObRawExpr(), ref_expr_(NULL)
{
set_expr_class(ObExpr::EXPR_ALIAS_REF);
@ -2354,7 +2354,7 @@ class ObAliasRefRawExpr : public ObRawExpr {
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_, N_VALUE,
ref_expr_, K_(enum_set_values));
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObAliasRefRawExpr);
ObRawExpr* ref_expr_;
int64_t project_index_; // project index of the subquery
@ -2362,7 +2362,7 @@ class ObAliasRefRawExpr : public ObRawExpr {
////////////////////////////////////////////////////////////////
class ObNonTerminalRawExpr : public ObRawExpr {
public:
public:
ObNonTerminalRawExpr() : ObRawExpr(), op_(NULL), input_types_()
{}
ObNonTerminalRawExpr(common::ObIAllocator& alloc) : ObRawExpr(alloc), op_(NULL), input_types_()
@ -2404,7 +2404,7 @@ class ObNonTerminalRawExpr : public ObRawExpr {
return seed;
}
protected:
protected:
// data members
ObExprOperator* op_;
ObExprResTypes input_types_;
@ -2413,7 +2413,7 @@ class ObNonTerminalRawExpr : public ObRawExpr {
////////////////////////////////////////////////////////////////
class ObOpRawExpr : public ObNonTerminalRawExpr, public jit::expr::ObOpExpr {
public:
public:
ObOpRawExpr()
: ObExpr(),
ObNonTerminalRawExpr(),
@ -2510,13 +2510,13 @@ class ObOpRawExpr : public ObNonTerminalRawExpr, public jit::expr::ObOpExpr {
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_,
K_(expr_levels), N_CHILDREN, exprs_);
protected:
protected:
common::ObSEArray<ObRawExpr*, COMMON_MULTI_NUM, common::ModulePageAllocator, true> exprs_;
ObSubQueryKey subquery_key_;
bool deduce_type_adding_implicit_cast_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObOpRawExpr);
};
@ -2588,7 +2588,7 @@ inline uint64_t ObOpRawExpr::hash_internal(uint64_t seed) const
////////////////////////////////////////////////////////////////
class ObCaseOpRawExpr : public ObNonTerminalRawExpr, public jit::expr::ObCaseOpExpr {
public:
public:
ObCaseOpRawExpr()
: ObExpr(),
ObNonTerminalRawExpr(),
@ -2679,7 +2679,7 @@ class ObCaseOpRawExpr : public ObNonTerminalRawExpr, public jit::expr::ObCaseOpE
K_(expr_levels), N_ARG_CASE, arg_expr_, N_DEFAULT, default_expr_, N_WHEN, when_exprs_, N_THEN, then_exprs_,
N_DECODE, is_decode_func_);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObCaseOpRawExpr);
ObRawExpr* arg_expr_;
common::ObSEArray<ObRawExpr*, COMMON_MULTI_NUM, common::ModulePageAllocator, true> when_exprs_;
@ -2823,7 +2823,7 @@ inline uint64_t ObCaseOpRawExpr::hash_internal(uint64_t seed) const
////////////////////////////////////////////////////////////////
class ObAggFunRawExpr : public ObRawExpr {
public:
public:
ObAggFunRawExpr()
: ObRawExpr(),
real_param_exprs_(),
@ -2976,7 +2976,7 @@ class ObAggFunRawExpr : public ObRawExpr {
K_(expr_level), K_(expr_levels), N_CHILDREN, real_param_exprs_, N_DISTINCT, distinct_, N_ORDER_BY, order_items_,
N_SEPARATOR_PARAM_EXPR, separator_param_expr_, K_(udf_meta), N_LINEAR_INTER_EXPR, linear_inter_expr_);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObAggFunRawExpr);
// real_param_exprs_.count() == 0 means '*'
common::ObSEArray<ObRawExpr*, 1, common::ModulePageAllocator, true> real_param_exprs_;
@ -3089,7 +3089,7 @@ inline int ObAggFunRawExpr::add_order_item(const OrderItem& order_item)
// for normal system function, func_name_ is used to distinguish them.
// for special system function, ObRawExpr::type_ can be reset. Such function may not need name
class ObSysFunRawExpr : public ObOpRawExpr {
public:
public:
ObSysFunRawExpr(common::ObIAllocator& alloc) : ObOpRawExpr(alloc), func_name_(), operator_id_(common::OB_INVALID_ID)
{
set_expr_class(ObExpr::EXPR_SYS_FUNC);
@ -3134,7 +3134,7 @@ class ObSysFunRawExpr : public ObOpRawExpr {
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_,
K_(expr_levels), N_FUNC, func_name_, N_CHILDREN, exprs_, K_(enum_set_values));
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObSysFunRawExpr);
common::ObString func_name_;
uint64_t operator_id_;
@ -3150,7 +3150,7 @@ inline const common::ObString& ObSysFunRawExpr::get_func_name() const
}
class ObSequenceRawExpr : public ObSysFunRawExpr {
public:
public:
ObSequenceRawExpr(common::ObIAllocator& alloc) : ObSysFunRawExpr(alloc), name_(), action_(), sequence_id_(0)
{}
ObSequenceRawExpr() : ObSysFunRawExpr(), name_(), action_(), sequence_id_(0)
@ -3175,14 +3175,14 @@ class ObSequenceRawExpr : public ObSysFunRawExpr {
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
virtual int get_name_internal(char* buf, const int64_t buf_len, int64_t& pos, ExplainType type) const override;
private:
private:
common::ObString name_; // sequence object name
common::ObString action_; // NEXTVAL or CURRVAL
uint64_t sequence_id_;
};
class ObNormalDllUdfRawExpr : public ObSysFunRawExpr {
public:
public:
ObNormalDllUdfRawExpr(common::ObIAllocator& alloc) : ObSysFunRawExpr(alloc), udf_meta_(), udf_attributes_()
{}
ObNormalDllUdfRawExpr() : ObSysFunRawExpr(), udf_meta_(), udf_attributes_()
@ -3201,14 +3201,14 @@ class ObNormalDllUdfRawExpr : public ObSysFunRawExpr {
}
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
private:
private:
// for udf function info
share::schema::ObUDFMeta udf_meta_;
common::ObSEArray<common::ObString, 16> udf_attributes_; // name of input expr
};
class ObPLSQLCodeSQLErrmRawExpr : public ObSysFunRawExpr {
public:
public:
ObPLSQLCodeSQLErrmRawExpr(common::ObIAllocator& alloc) : ObSysFunRawExpr(alloc), is_sqlcode_(true)
{}
ObPLSQLCodeSQLErrmRawExpr() : ObSysFunRawExpr(), is_sqlcode_(true)
@ -3230,15 +3230,15 @@ class ObPLSQLCodeSQLErrmRawExpr : public ObSysFunRawExpr {
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_,
K_(expr_level), K_(expr_levels), K_(is_sqlcode), N_CHILDREN, exprs_);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObPLSQLCodeSQLErrmRawExpr);
private:
private:
bool is_sqlcode_;
};
class ObObjAccessRawExpr : public ObOpRawExpr {
public:
public:
ObObjAccessRawExpr(common::ObIAllocator& alloc)
: ObOpRawExpr(alloc), get_attr_func_(0), func_name_(), var_indexs_(), for_write_(false)
{}
@ -3280,7 +3280,7 @@ class ObObjAccessRawExpr : public ObOpRawExpr {
for_write_ = for_write;
}
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObObjAccessRawExpr);
uint64_t get_attr_func_;
common::ObString func_name_;
@ -3307,7 +3307,7 @@ enum ObMultiSetModifier {
};
class ObMultiSetRawExpr : public ObOpRawExpr {
public:
public:
ObMultiSetRawExpr(common::ObIAllocator& alloc)
: ObOpRawExpr(alloc),
ms_modifier_(ObMultiSetModifier::MULTISET_MODIFIER_INVALID),
@ -3345,14 +3345,14 @@ class ObMultiSetRawExpr : public ObOpRawExpr {
ms_type_ = type;
}
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObMultiSetRawExpr);
ObMultiSetModifier ms_modifier_;
ObMultiSetType ms_type_;
};
class ObCollPredRawExpr : public ObMultiSetRawExpr {
public:
public:
ObCollPredRawExpr(common::ObIAllocator& alloc) : ObMultiSetRawExpr(alloc)
{}
virtual ~ObCollPredRawExpr()
@ -3363,12 +3363,12 @@ class ObCollPredRawExpr : public ObMultiSetRawExpr {
bool use_new_allocator = false);
virtual bool same_as(const ObRawExpr& expr, ObExprEqualCheckContext* check_context = NULL) const override;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObCollPredRawExpr);
};
class ObFunMatchAgainst : public ObNonTerminalRawExpr {
public:
public:
ObFunMatchAgainst()
: ObNonTerminalRawExpr(),
mode_flag_(NATURAL_LANGUAGE_MODE),
@ -3464,7 +3464,7 @@ class ObFunMatchAgainst : public ObNonTerminalRawExpr {
VIRTUAL_TO_STRING_KV(
N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_, K_(mode_flag));
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObFunMatchAgainst);
ObMatchAgainstMode mode_flag_;
ObRawExpr* match_columns_;
@ -3474,7 +3474,7 @@ class ObFunMatchAgainst : public ObNonTerminalRawExpr {
};
class ObSetIterRawExpr : public ObNonTerminalRawExpr {
public:
public:
ObSetIterRawExpr() : ObNonTerminalRawExpr(), left_iter_(NULL), right_iter_(NULL)
{
set_expr_class(ObExpr::EXPR_DOMAIN_INDEX);
@ -3515,14 +3515,14 @@ class ObSetIterRawExpr : public ObNonTerminalRawExpr {
}
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObSetIterRawExpr);
ObRawExpr* left_iter_;
ObRawExpr* right_iter_;
};
class ObRowIterRawExpr : public ObTerminalRawExpr {
public:
public:
ObRowIterRawExpr() : ObTerminalRawExpr(), iter_idx_(common::OB_INVALID_INDEX)
{
set_expr_class(ObExpr::EXPR_DOMAIN_INDEX);
@ -3552,7 +3552,7 @@ class ObRowIterRawExpr : public ObTerminalRawExpr {
}
VIRTUAL_TO_STRING_KV(N_ITEM_TYPE, type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_, K_(iter_idx));
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObRowIterRawExpr);
int64_t iter_idx_;
};
@ -3578,7 +3578,7 @@ enum BoundExprIdx { BOUND_EXPR_ADD = 0, BOUND_EXPR_SUB, BOUND_EXPR_MAX };
struct Bound {
OB_UNIS_VERSION_V(1);
public:
public:
Bound()
: type_(BOUND_UNBOUNDED),
is_preceding_(false),
@ -3607,7 +3607,7 @@ struct Bound {
////////////////////////////////////////////////////////////////
struct ObFrame {
public:
public:
ObFrame() : win_type_(WINDOW_MAX), is_between_(false)
{}
inline void set_window_type(WindowType win_type)
@ -3652,7 +3652,7 @@ struct ObFrame {
};
struct ObWindow : public ObFrame {
public:
public:
ObWindow() : has_frame_orig_(false)
{
partition_exprs_.set_label(common::ObModIds::OB_SQL_WINDOW_FUNC);
@ -3713,7 +3713,7 @@ struct ObWindow : public ObFrame {
};
class ObWinFunRawExpr : public ObRawExpr, public ObWindow {
public:
public:
ObWinFunRawExpr()
: ObRawExpr(),
ObWindow(),
@ -3831,10 +3831,10 @@ class ObWinFunRawExpr : public ObRawExpr, public ObWindow {
K_(expr_level), K_(expr_levels), K_(func_type), K_(is_distinct), K_(func_params), K_(partition_exprs),
K_(order_items), K_(win_type), K_(is_between), K_(upper), K_(lower), KPC_(agg_expr));
public:
public:
common::ObString sort_str_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObWinFunRawExpr);
ObItemType func_type_;
bool is_distinct_;
@ -3846,7 +3846,7 @@ class ObWinFunRawExpr : public ObRawExpr, public ObWindow {
////////////////////////////////////////////////////////////////
class ObPseudoColumnRawExpr : public ObTerminalRawExpr {
public:
public:
ObPseudoColumnRawExpr() : ObTerminalRawExpr(), table_id_(common::OB_INVALID_ID)
{
set_expr_class(ObExpr::EXPR_PSEUDO_COLUMN);
@ -3896,7 +3896,7 @@ class ObPseudoColumnRawExpr : public ObTerminalRawExpr {
VIRTUAL_TO_STRING_KV(
N_ITEM_TYPE, type_, N_RESULT_TYPE, result_type_, N_EXPR_INFO, info_, N_REL_ID, rel_ids_, N_TABLE_ID, table_id_);
private:
private:
ObRawExpr* cte_cycle_value_;
ObRawExpr* cte_cycle_default_value_;
int64_t table_id_;
@ -3904,7 +3904,7 @@ class ObPseudoColumnRawExpr : public ObTerminalRawExpr {
};
/// visitor interface
class ObRawExprVisitor {
public:
public:
ObRawExprVisitor()
{}
virtual ~ObRawExprVisitor()
@ -3966,13 +3966,13 @@ class ObRawExprVisitor {
return false;
}
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprVisitor);
};
class ObRawExprFactory {
public:
public:
explicit ObRawExprFactory(common::ObIAllocator& alloc) : allocator_(alloc), expr_store_(alloc)
{}
~ObRawExprFactory()
@ -4025,16 +4025,16 @@ class ObRawExprFactory {
}
TO_STRING_KV("", "");
private:
private:
common::ObIAllocator& allocator_;
common::ObObjStore<ObRawExpr*, common::ObIAllocator&, true> expr_store_;
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObRawExprFactory);
};
class ObRawExprPointer {
public:
public:
ObRawExprPointer();
virtual ~ObRawExprPointer();
@ -4043,7 +4043,7 @@ class ObRawExprPointer {
int add_ref(ObRawExpr** expr);
TO_STRING_KV("", "");
private:
private:
common::ObSEArray<ObRawExpr**, 1> expr_group_;
};

8
src/sql/resolver/expr/ob_raw_expr_canonicalizer.h
View File

@ -16,7 +16,7 @@
namespace oceanbase {
namespace sql {
class ObRawExprCanonicalizer {
public:
public:
ObRawExprCanonicalizer()
{}
virtual ~ObRawExprCanonicalizer()
@ -30,13 +30,13 @@ class ObRawExprCanonicalizer {
*/
virtual int canonicalize(ObRawExpr*& expr) = 0;
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprCanonicalizer);
// function members
private:
private:
// data members
};

10
src/sql/resolver/expr/ob_raw_expr_canonicalizer_impl.h
View File

@ -16,16 +16,16 @@
namespace oceanbase {
namespace sql {
class ObRawExprCanonicalizerImpl : public ObRawExprCanonicalizer {
public:
public:
explicit ObRawExprCanonicalizerImpl(ObExprResolveContext& ctx);
virtual ~ObRawExprCanonicalizerImpl()
{}
virtual int canonicalize(ObRawExpr*& expr);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprCanonicalizerImpl);
// function members
@ -38,7 +38,7 @@ class ObRawExprCanonicalizerImpl : public ObRawExprCanonicalizer {
int pull_similar_expr(ObRawExpr*& expr);
int cluster_and_or(ObRawExpr*& expr);
private:
private:
struct ObOppositeOpPair {
ObItemType original_;
ObItemType opposite_;
@ -46,7 +46,7 @@ class ObRawExprCanonicalizerImpl : public ObRawExprCanonicalizer {
static ObItemType get_opposite_op(ObItemType type);
static ObOppositeOpPair OPPOSITE_PAIRS[];
private:
private:
// data members
ObExprResolveContext& ctx_;
// ObIAllocator &allocator_;

4
src/sql/resolver/expr/ob_raw_expr_ctxcat_analyzer.h
View File

@ -20,14 +20,14 @@ namespace oceanbase {
namespace sql {
class ObSQLSessionInfo;
class ObRawExprCtxCatAnalyzer {
public:
public:
ObRawExprCtxCatAnalyzer(ObRawExprFactory& expr_factory, ObSQLSessionInfo* session_info)
: expr_factory_(expr_factory), session_info_(session_info)
{}
// int splite_search_keywords(ObFunMatchAgainst &expr);
int create_fulltext_filter(ObFunMatchAgainst& expr);
private:
private:
ObRawExprFactory& expr_factory_;
ObSQLSessionInfo* session_info_;
};

8
src/sql/resolver/expr/ob_raw_expr_deduce_type.h
View File

@ -19,7 +19,7 @@
namespace oceanbase {
namespace sql {
class ObRawExprDeduceType : public ObRawExprVisitor {
public:
public:
ObRawExprDeduceType(const ObSQLSessionInfo* my_session)
: ObRawExprVisitor(), my_session_(my_session), alloc_(), expr_factory_(NULL)
{}
@ -54,9 +54,9 @@ class ObRawExprDeduceType : public ObRawExprVisitor {
int check_type_for_case_expr(ObCaseOpRawExpr& case_expr, common::ObIAllocator& alloc);
static bool skip_cast_expr(const ObRawExpr& parent, const int64_t child_idx);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprDeduceType);
// function members
@ -101,7 +101,7 @@ class ObRawExprDeduceType : public ObRawExprVisitor {
int add_group_aggr_implicit_cast(ObAggFunRawExpr& expr, const ObCastMode& cast_mode);
int adjust_cast_as_signed_unsigned(ObSysFunRawExpr& expr);
private:
private:
const sql::ObSQLSessionInfo* my_session_;
common::ObArenaAllocator alloc_;
ObRawExprFactory* expr_factory_;

6
src/sql/resolver/expr/ob_raw_expr_info_extractor.h
View File

@ -16,7 +16,7 @@
namespace oceanbase {
namespace sql {
class ObRawExprInfoExtractor : public ObRawExprVisitor {
public:
public:
ObRawExprInfoExtractor() : ObRawExprVisitor()
{}
virtual ~ObRawExprInfoExtractor()
@ -39,9 +39,9 @@ class ObRawExprInfoExtractor : public ObRawExprVisitor {
virtual int visit(ObWinFunRawExpr& expr);
virtual int visit(ObPseudoColumnRawExpr& expr);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprInfoExtractor);
// function members

4
src/sql/resolver/expr/ob_raw_expr_modify_column_name.h
View File

@ -19,7 +19,7 @@
namespace oceanbase {
namespace sql {
class ObRawExprModifyColumnName : public ObRawExprVisitor {
public:
public:
ObRawExprModifyColumnName(common::ObString new_column_name, common::ObString orig_column_name) : ObRawExprVisitor()
{
orig_column_name_ = orig_column_name;
@ -45,7 +45,7 @@ class ObRawExprModifyColumnName : public ObRawExprVisitor {
virtual int visit(ObWinFunRawExpr& expr);
virtual int visit(ObPseudoColumnRawExpr& expr);
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObRawExprModifyColumnName);
common::ObString orig_column_name_;
common::ObString new_column_name_;

6
src/sql/resolver/expr/ob_raw_expr_part_expr_checker.h
View File

@ -18,7 +18,7 @@ namespace oceanbase {
namespace sql {
class ObRawExprPartExprChecker : public ObRawExprVisitor {
public:
public:
ObRawExprPartExprChecker() : ObRawExprVisitor()
{}
virtual ~ObRawExprPartExprChecker()
@ -36,9 +36,9 @@ class ObRawExprPartExprChecker : public ObRawExprVisitor {
virtual int visit(ObSetOpRawExpr& expr);
virtual int visit(ObAliasRefRawExpr& expr);
private:
private:
// types and constants
private:
private:
inline static bool is_time_expr(const ObRawExpr& expr);
inline static bool is_date_expr(const ObRawExpr& expr);
inline static bool is_timestamp_expr(const ObRawExpr& expr);

6
src/sql/resolver/expr/ob_raw_expr_part_func_checker.h
View File

@ -18,7 +18,7 @@ namespace oceanbase {
namespace sql {
class ObRawExprPartFuncChecker : public ObRawExprVisitor {
public:
public:
explicit ObRawExprPartFuncChecker(bool gen_col_check = false, bool accept_charset_function = false)
: ObRawExprVisitor(), gen_col_check_(gen_col_check), accept_charset_function_(accept_charset_function)
{}
@ -37,12 +37,12 @@ class ObRawExprPartFuncChecker : public ObRawExprVisitor {
virtual int visit(ObSetOpRawExpr& expr);
virtual int visit(ObAliasRefRawExpr& expr);
private:
private:
// types and constants
bool gen_col_check_;
bool accept_charset_function_;
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprPartFuncChecker);
};

6
src/sql/resolver/expr/ob_raw_expr_precalc_analyzer.h
View File

@ -21,7 +21,7 @@ class ObDMLStmt;
class ObRawExprFactory;
class ObSQLSessionInfo;
class ObRawExprPrecalcAnalyzer {
public:
public:
ObRawExprPrecalcAnalyzer(ObRawExprFactory& expr_factory, ObSQLSessionInfo* my_session)
: expr_factory_(expr_factory), my_session_(my_session)
{}
@ -29,7 +29,7 @@ class ObRawExprPrecalcAnalyzer {
int analyze_all_expr(ObDMLStmt& stmt);
int analyze_expr_tree(ObRawExpr* expr, ObDMLStmt& stmt, const bool filter_expr = false);
private:
private:
int pre_cast_const_expr(ObRawExpr* expr);
int pre_cast_recursively(ObRawExpr* expr);
int extract_calculable_expr(ObRawExpr*& expr, ObDMLStmt& stmt, const bool filter_expr = false);
@ -38,7 +38,7 @@ class ObRawExprPrecalcAnalyzer {
bool calculation_need_cast(common::ObObjType param_type, common::ObObjType calc_type) const;
bool is_filtered(ObRawExpr& expr);
private:
private:
const static ObItemType EXPR_FILTER_LIST[];
ObRawExprFactory& expr_factory_;
ObSQLSessionInfo* my_session_;

8
src/sql/resolver/expr/ob_raw_expr_print_visitor.h
View File

@ -17,7 +17,7 @@
namespace oceanbase {
namespace sql {
class ObRawExprPrintVisitor : public ObRawExprVisitor {
public:
public:
explicit ObRawExprPrintVisitor(ObRawExpr& expr_root);
virtual ~ObRawExprPrintVisitor();
@ -32,13 +32,13 @@ class ObRawExprPrintVisitor : public ObRawExprVisitor {
virtual int visit(ObSetOpRawExpr& expr);
int64_t to_string(char* buf, const int64_t buf_len) const;
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprPrintVisitor);
// function members
private:
private:
// data members
ObRawExpr& expr_root_;
mutable char* buf_;

6
src/sql/resolver/expr/ob_raw_expr_printer.h
View File

@ -71,7 +71,7 @@ class ObRawExprPrinter {
#define BINARY_COLLATION 63
#define INVALID_COLLATION 0
public:
public:
ObRawExprPrinter();
ObRawExprPrinter(
char* buf, int64_t buf_len, int64_t* pos, common::ObObjPrintParams print_params = common::ObObjPrintParams());
@ -81,7 +81,7 @@ class ObRawExprPrinter {
void init(char* buf, int64_t buf_len, int64_t* pos, ObObjPrintParams print_params);
int do_print(ObRawExpr* expr, ObStmtScope scope, bool only_column_namespace = false);
private:
private:
int print(ObRawExpr* expr);
int print(ObConstRawExpr* expr);
@ -106,7 +106,7 @@ class ObRawExprPrinter {
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprPrinter);
private:
private:
// data members
char* buf_;
int64_t buf_len_;

8
src/sql/resolver/expr/ob_raw_expr_replacer.h
View File

@ -17,7 +17,7 @@
namespace oceanbase {
namespace sql {
class ObRawExprReplacer : public ObRawExprVisitor {
public:
public:
ObRawExprReplacer(ObRawExpr* old_expr, ObRawExpr* new_expr);
virtual ~ObRawExprReplacer();
@ -33,13 +33,13 @@ class ObRawExprReplacer : public ObRawExprVisitor {
virtual int visit(ObSetOpRawExpr& expr);
virtual int visit(ObWinFunRawExpr& expr);
private:
private:
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprReplacer);
// function members
private:
private:
ObRawExpr* old_expr_;
ObRawExpr* new_expr_;
};

6
src/sql/resolver/expr/ob_raw_expr_resolver.h
View File

@ -20,7 +20,7 @@
namespace oceanbase {
namespace sql {
class ObRawExprResolver {
public:
public:
ObRawExprResolver()
{}
@ -32,11 +32,11 @@ class ObRawExprResolver {
common::ObIArray<ObAggFunRawExpr*>& aggr_exprs, common::ObIArray<ObWinFunRawExpr*>& win_exprs,
common::ObIArray<ObOpRawExpr*>& op_exprs, common::ObIArray<ObUserVarIdentRawExpr*>& user_var_exprs) = 0;
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprResolver);
// function members
private:
private:
// data members
};

6
src/sql/resolver/expr/ob_raw_expr_resolver_impl.h
View File

@ -34,7 +34,7 @@ class ObRawExprResolverImpl : public ObRawExprResolver {
int ret_;
};
public:
public:
explicit ObRawExprResolverImpl(ObExprResolveContext& ctx);
virtual ~ObRawExprResolverImpl()
{}
@ -56,7 +56,7 @@ class ObRawExprResolverImpl : public ObRawExprResolver {
static int check_sys_func(ObQualifiedName& q_name, bool& is_sys_func);
// types and constants
private:
private:
// disallow copy
DISALLOW_COPY_AND_ASSIGN(ObRawExprResolverImpl);
// function members
@ -141,7 +141,7 @@ class ObRawExprResolverImpl : public ObRawExprResolver {
static int not_row_check(const ObRawExpr* expr);
static int param_not_row_check(const ObRawExpr* expr);
private:
private:
int transform_ratio_afun_to_arg_div_sum(const ParseNode* ratio_to_report, ParseNode*& div);
int convert_any_or_all_expr(ObRawExpr*& expr, bool& happened);
int get_opposite_string(

14
src/sql/resolver/expr/ob_raw_expr_util.h
View File

@ -36,7 +36,7 @@ class ObSelectIntoItem;
template <class T>
class UniqueSetWrapAllocer {
public:
public:
UniqueSetWrapAllocer() : allocator_(NULL)
{}
UniqueSetWrapAllocer(ObIAllocator& alloc) : allocator_(&alloc)
@ -65,12 +65,12 @@ class UniqueSetWrapAllocer {
void dec_ref()
{}
private:
private:
ObIAllocator* allocator_;
};
class ObRawExprUniqueSet {
public:
public:
typedef UniqueSetWrapAllocer<typename common::hash::HashSetTypes<uint64_t>::AllocType> NodeAllocator;
typedef common::hash::ObHashSet<uint64_t, common::hash::NoPthreadDefendMode, common::hash::hash_func<uint64_t>,
common::hash::equal_to<uint64_t>, NodeAllocator, common::hash::NormalPointer, common::ObWrapperAllocator,
@ -99,10 +99,10 @@ class ObRawExprUniqueSet {
return expr_array_;
};
private:
private:
DISALLOW_COPY_AND_ASSIGN(ObRawExprUniqueSet);
private:
private:
NodeAllocator node_allocator_;
common::ObWrapperAllocator bucket_allocator_;
ExprPtrSet expr_set_;
@ -143,7 +143,7 @@ int ObRawExprUniqueSet::append(const ObIArray<RawExprType*>& exprs)
}
class ObRawExprUtils {
public:
public:
/**
* make expression from string
*
@ -425,7 +425,7 @@ class ObRawExprUtils {
static int build_to_outfile_expr(ObRawExprFactory& expr_factory, const ObSQLSessionInfo* session_info,
const ObSelectIntoItem* into_item, const ObIArray<ObRawExpr*>& exprs, ObRawExpr*& to_outfile_expr);
private:
private:
static int create_real_cast_expr(ObRawExprFactory& expr_factory, ObRawExpr* src_expr, const ObExprResType& dst_type,
ObSysFunRawExpr*& func_expr, const ObSQLSessionInfo* session_info);
ObRawExprUtils();

6
src/sql/resolver/expr/ob_raw_expr_wrap_enum_set.h
View File

@ -23,7 +23,7 @@ class ObInsertStmt;
class ObSQLSessionInfo;
class ObRawExprWrapEnumSet : public ObRawExprVisitor {
public:
public:
ObRawExprWrapEnumSet(ObRawExprFactory& expr_factory, ObSQLSessionInfo* my_session)
: ObRawExprVisitor(), current_level_(-1), expr_factory_(expr_factory), my_session_(my_session)
{}
@ -45,7 +45,7 @@ class ObRawExprWrapEnumSet : public ObRawExprVisitor {
int visit(ObFunMatchAgainst& expr);
bool skip_child();
private:
private:
int32_t get_current_level() const
{
return current_level_;
@ -61,7 +61,7 @@ class ObRawExprWrapEnumSet : public ObRawExprVisitor {
int wrap_value_vector(ObInsertStmt& stmt);
int wrap_nullif_expr(ObSysFunRawExpr& expr);
private:
private:
int32_t current_level_;
ObRawExprFactory& expr_factory_;
ObSQLSessionInfo* my_session_;

2
src/sql/resolver/expr/ob_var_expr.h
View File

@ -23,7 +23,7 @@ namespace expr {
// OceanBase constant expression.
class ObVarExpr : virtual public ObExpr {
public:
public:
ObVarExpr()
{
set_expr_class(EXPR_VAR);