oceanbase/src/sql/parser/parse_node.h

/**
 * 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_PARSER_PARSE_NODE_H_
#define OCEANBASE_SQL_PARSER_PARSE_NODE_H_

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdbool.h>
#include <setjmp.h>
#ifdef SQL_PARSER_COMPILATION
#include "ob_sql_mode.h"
#include "ob_item_type.h"
#else
#include "common/sql_mode/ob_sql_mode.h"
#include "objit/common/ob_item_type.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif

#define MAX_ERROR_MSG 1024

struct ObCharsetInfo;

enum SelectParserOffset
{
  PARSE_SELECT_WITH,
  PARSE_SELECT_DISTINCT,
  PARSE_SELECT_SELECT,
  PARSE_SELECT_INTO, //into before from
  PARSE_SELECT_FROM,
  PARSE_SELECT_WHERE,
  PARSE_SELECT_DYNAMIC_SW_CBY, // connect by node or start with node
  PARSE_SELECT_DYNAMIC_CBY_SW, // connect by node or start with node
  PARSE_SELECT_DYNAMIC_GROUP,
  PARSE_SELECT_DYNAMIC_HAVING,
  PARSE_SELECT_NAMED_WINDOWS,
  PARSE_SELECT_SET,
  PARSE_SELECT_FORMER,
  PARSE_SELECT_LATER,
  PARSE_SELECT_ORDER,
  PARSE_SELECT_LIMIT,
  PARSE_SELECT_FOR_UPD,
  PARSE_SELECT_HINTS,
  PARSE_SELECT_WHEN,
  PARSE_SELECT_FETCH,
  PARSE_SELECT_FETCH_TEMP, //use to temporary store fetch clause in parser
  PARSE_SELECT_WITH_CHECK_OPTION,
  PARSE_SELECT_INTO_EXTRA,// ATTENTION!! SELECT_INTO_EXTRA must be the last one
  PARSE_SELECT_MAX_IDX
};

enum GrantParseOffset
{
  PARSE_GRANT_ROLE_LIST,
  PARSE_GRANT_ROLE_GRANTEE,
  PARSE_GRANT_ROLE_OPT_WITH,
  PARSE_GRANT_ROLE_MAX_IDX
};

enum GrantParseSysOffset
{
  PARSE_GRANT_SYS_PRIV_ORACLE_LIST,
  PARSE_GRANT_SYS_PRIV_ORACLE_GRANTEE,
  PARSE_GRANT_SYS_PRIV_ORACLE_OPT_WITH,
  PARSE_GRANT_SYS_PRIV_ORACLE_MAX_IDX
};

enum ParseMode
{
  STD_MODE = 0,
  FP_MODE, /* fast parse,保留hint，且做参数化*/
  MULTI_MODE ,/* multi query ultra-fast parse */
  FP_PARAMERIZE_AND_FILTER_HINT_MODE,/*过滤掉hint，并且做参数化*/
  FP_NO_PARAMERIZE_AND_FILTER_HINT_MODE,/*过滤掉hint，并且不做参数化*/
  TRIGGER_MODE, /* treat ':xxx' as identifier */
  DYNAMIC_SQL_MODE, /*解析动态sql过程中，:idx和:identifier要根据语句类型确定是否检查placeholder的名字*/
  DBMS_SQL_MODE,
  UDR_SQL_MODE,
  INS_MULTI_VALUES,
};

typedef struct
{
  int err_code_;
  char err_msg_[MAX_ERROR_MSG];
} ErrStat;

struct _ParseNode;

typedef struct _ObStmtLoc
{
  int first_column_;
  int last_column_;
  int first_line_;
  int last_line_;
} ObStmtLoc;

enum UdtUdfType
{
  UDT_UDF_UNKNOWN,
  UDT_UDF_CONS = 1,
  UDT_UDF_MEMBER = 2,
  UDT_UDF_STATIC = 4,
  UDT_UDF_MAP = 8,
  UDT_UDF_ORDER = 16,
};

typedef struct _ParseNode
{
  ObItemType type_;
  int32_t num_child_;   /* attributes for non-terninal node, which has children */
  int16_t param_num_; //记录该node对应的原始text中常量的个数, 暂时仅T_CAST_ARGUMENT使用
  union {
    uint32_t flag_;
    struct {
      uint32_t is_neg_ : 1;// 记录常量节点的父节点是否为T_OP_NEG节点, 1表示是, 0 表示不是
      uint32_t is_hidden_const_ : 1; //1 表示某常量正常parse能识别但fast parse不能识别, 0 表示都能识别。
      uint32_t is_tree_not_param_ :1; //1 表示该节点及其子节点常量均不能参数化, 0表示没该限制
      uint32_t length_semantics_  :2; //2 for oracle [char|varbinary] (n b [bytes|char])
      uint32_t is_val_paramed_item_idx_ :1; // T_PROJECT_STRING的values是否是select_item_param_infos数组的下标
      uint32_t is_copy_raw_text_ : 1; // 是否回填常量节点的raw_text_，用于select item常量参数化
      uint32_t is_column_varchar_ : 1; // 投影列是否是一个常量字符串，用于select item常量参数化
      uint32_t is_trans_from_minus_: 1; // 负数常量节点是否是从减号操作转换而来，比如1 - 2，词法阶段会生成一个-2
      uint32_t is_assigned_from_child_: 1; // 常量节点是否由子节点赋值得到，用于处理int64_min
      uint32_t is_num_must_be_pos_: 1; //
      uint32_t is_date_unit_ : 1; //1 表示是date unit常量，在反拼的时候需要反拼为字符串
      uint32_t is_literal_bool_ : 1; // indicate node is a literal TRUE/FALSE
      uint32_t is_empty_ : 1; // 表示是否缺省该节点，1表示缺省，0表示没有缺省, opt_asc_desc节点中使用到
      uint32_t is_multiset_ : 1; // for cast(multiset(...) as ...)
      uint32_t is_forbid_anony_parameter_ : 1; // 1 表示禁止匿名块参数化
      uint32_t is_input_quoted_ : 1; // indicate name_ob input whether with double quote
      uint32_t is_forbid_parameter_ : 1; //1 indicate forbid parameter
      uint32_t reserved_;
    };
  };
  /* attributes for terminal node, it is real value */
  /* 数值类型的node将用到value_来存放其值，但是对于字符串和decimal类型，用str_value来存字符串指针，
   * str_len_表示字符串的长度，不要用strlen(str_value_)来获取str_value_的值，因为str_value_不保证以'\0'结尾.
   * 此外，为什么不将value_和str_len_作为union呢，这是因为在parse
   * 一个数值类型的时候,不仅需要存储其value，还需要存储其原始字符串，举例：select
   * 1111;这种语句，我们不仅要存int value的值，还得存'1111' 字符串*/
  union {
    int64_t value_;
    int32_t int32_values_[2];
    int16_t int16_values_[4];
  };
  const char *str_value_;
  int64_t str_len_;
  union {
    int64_t pl_str_off_; // pl层, 记录str在原始字符串中的起始偏移
    int64_t sql_str_off_; // sql层, 记录str在原始字符串中的起始偏移
  };

  /* 用于存放在词法阶段被特殊处理后丢失的文本串 eg: NULL, Date '2010-10-11',
   * 该文本串在fast parse参数化后，如果该参数作为plan cache中stmtkey的一部分，
   * 则需要使用原始的文本串，而不是丢失文本串后的值，否则会导致plan cache误匹配
   * */
  const char *raw_text_;
  int64_t text_len_;
  int64_t pos_; //记录?在带?的sql中的偏移

  struct _ParseNode **children_; /* attributes for non-terminal node, which has children */
  ObStmtLoc stmt_loc_; //临时放在这里，后面要移到parse_stmt_node.h中去
  union {
    int64_t raw_param_idx_; // 常量节点在fp_result.raw_params_中的下标
    int64_t raw_sql_offset_; // 常量节点在sql中的字符偏移
  };

#ifdef SQL_PARSER_COMPILATION
  int token_off_;
  int token_len_;
#endif
} ParseNode;

struct _ParamList;

typedef struct _ParamList
{
  ParseNode *node_;
  struct _ParamList *next_;
} ParamList;

//供parser使用的外部依赖对象类型
enum RefType
{
  REF_REL = 0,
  REF_PROC,
  REF_FUNC,
};

//外部依赖对象链表
typedef struct _RefObjList
{
  enum RefType type_;
  ParseNode *node_;
  struct _RefObjList *next_;
} RefObjList;

//解析PL中sql语句时需要使用的属性集合
typedef struct _PLParseInfo
{
  bool is_pl_parse_;//用于标识当前parser逻辑是否为PLParse调用
  bool is_pl_parse_expr_; //用于标识当前parser逻辑是否在解析PLParser的expr
  bool is_forbid_pl_fp_;
  bool is_inner_parse_;
  int last_pl_symbol_pos_; //上一个pl变量的结束位置
  int plsql_line_;
  /*for mysql pl*/
  void *pl_ns_; //ObPLBlockNS
  RefObjList *ref_object_nodes_; //依赖对象链表头
  RefObjList *tail_ref_object_node_; //依赖对象链表尾
} PLParseInfo;

//跟@如巅讨论，此处的定义后续会改成动态的，此处先定义128
#define MAX_QUESTION_MARK 128

typedef struct _ObQuestionMarkCtx
{
  char **name_;
  int count_;
  int capacity_;
  bool by_ordinal_;
  bool by_name_;
  bool by_defined_name_;
} ObQuestionMarkCtx;


// record the minus status while parsing the sql
// for example, 'select - -1 from dual'
// when parser sees the first '-', pos_ = 7, raw_sql_offset = 7, has_minus_ = true, is_cur_numeric_ = false
// after seeing the second '-', members are reseted, pos_ = 9, raw_sql_offset_ = 9, has_minus_ = true,  is_cur_numeric = false
// after seeing '1', is_cur_numeric = true, then param node '-1' is returned
typedef struct _ObMinusStatuCtx
{
  int pos_; // 负数在参数化后的sql中出现的位置
  int raw_sql_offset_; // 负号在原始sql中出现的位置
  bool has_minus_; // 保留一下负号的状态，在遇到数值类型的时候，词法返回一个负数节点
  bool is_cur_numeric_; // 当前常量节点是否是数值节点
} ObMinusStatusCtx;

#ifdef SQL_PARSER_COMPILATION
// for comment_list_ in ParseResult
typedef struct TokenPosInfo
{
  int token_off_;
  int token_len_;
} TokenPosInfo;
#endif

//外部依赖对象链表
typedef struct _ParenthesesOffset
{
  int left_parentheses_;
  int right_parentheses_;
  struct _ParenthesesOffset *next_;
} ParenthesesOffset;

//dml base runtime context definition
typedef struct _InsMultiValuesResult
{
  ParenthesesOffset *ref_parentheses_;
  ParenthesesOffset *tail_parentheses_;
  int values_col_;
  int values_count_;
  int on_duplicate_pos_; // the start position of on duplicate key in insert ... on duplicate key update statement
  int ret_code_;
} InsMultiValuesResult;


typedef struct
{
  void *yyscan_info_;
  const char *input_sql_;
  int input_sql_len_;
  int param_node_num_;
  int token_num_;
  void *malloc_pool_; // ObIAllocator
  ObQuestionMarkCtx question_mark_ctx_;
  ObSQLMode sql_mode_;
  const struct ObCharsetInfo *charset_info_; //client charset
  const struct ObCharsetInfo *charset_info_oracle_db_; //oracle DB charset
  ParamList *param_nodes_;
  ParamList *tail_param_node_;
  struct {
    uint32_t has_encount_comment_              : 1;
    uint32_t is_fp_                            : 1;
    uint32_t is_multi_query_                   : 1;
    uint32_t is_ignore_hint_                   : 1;//used for outline
    uint32_t is_ignore_token_                  : 1;//used for outline
    uint32_t need_parameterize_                : 1;//used for outline, to support signature of outline can contain hint
    uint32_t in_q_quote_                       : 1;
    uint32_t is_for_trigger_                   : 1;
    uint32_t is_dynamic_sql_                   : 1;
    uint32_t is_dbms_sql_                      : 1;
    uint32_t is_batched_multi_enabled_split_   : 1;
    uint32_t is_not_utf8_connection_           : 1;
    uint32_t may_bool_value_                   : 1; // used for true/false in sql parser
    uint32_t is_include_old_new_in_trigger_    : 1;
    uint32_t is_normal_ps_prepare_             : 1;
    uint32_t is_multi_values_parser_           : 1;
    uint32_t is_for_udr_                       : 1;
    uint32_t is_for_remap_                     : 1;
    uint32_t contain_sensitive_data_           : 1;
    uint32_t may_contain_sensitive_data_       : 1;
  };

  ParseNode *result_tree_;
  jmp_buf *jmp_buf_;//handle fatal error
  int extra_errno_;
  char *error_msg_;
  int start_col_;
  int end_col_;
  int line_;
  int yycolumn_;
  int yylineno_;
  char *tmp_literal_;
  /* for multi query fast parse (split queries) */
  char *no_param_sql_;
  int no_param_sql_len_;
  int no_param_sql_buf_len_;
  /*for pl*/
  PLParseInfo pl_parse_info_;
  /*for  q-quote*/
  ObMinusStatusCtx minus_ctx_; // for fast parser to parse negative value
  int64_t last_escape_check_pos_;  //解析quoted string%parse-param时的一个临时变量，处理连接gbk字符集时遇到的转义字符问题
  int connection_collation_;//connection collation
  bool mysql_compatible_comment_; //whether the parser is parsing "/*! xxxx */"
  bool enable_compatible_comment_;

  InsMultiValuesResult *ins_multi_value_res_;


#ifdef SQL_PARSER_COMPILATION
  TokenPosInfo *comment_list_;
  int comment_cnt_;
  int comment_cap_;
  int realloc_cnt_;
  bool stop_add_comment_;
#endif
} ParseResult;

typedef struct _ObFastParseCtx
{
  bool is_fp_;
} ObFastParseCtx;

typedef enum ObSizeUnitType
{
  SIZE_UNIT_TYPE_INVALID = -1,
  SIZE_UNIT_TYPE_K,
  SIZE_UNIT_TYPE_M,
  SIZE_UNIT_TYPE_G,
  SIZE_UNIT_TYPE_T,
  SIZE_UNIT_TYPE_P,
  SIZE_UNIT_TYPE_E,
  SIZE_UNIT_TYPE_MAX
} ObSizeUnitType;

extern int parse_init(ParseResult *p);
extern int parse_terminate(ParseResult *p);
extern int parse_sql(ParseResult *p, const char *pszSql, size_t iLen);
extern void destroy_tree(ParseNode *pRoot);
extern unsigned char escaped_char(unsigned char c, int *with_back_slash);
extern char *str_tolower(char *buff, int64_t len);
extern char *str_toupper(char *buff, int64_t len);
extern int64_t str_remove_space(char *buff, int64_t len);
//extern int64_t ob_parse_string(const char *src, char *dest, int64_t len, int quote_type);

extern ParseNode *new_node(void *malloc_pool, ObItemType type, int num);
extern ParseNode *new_non_terminal_node(void *malloc_pool, ObItemType node_tag, int num, ...);
extern ParseNode *new_terminal_node(void *malloc_pool, ObItemType type);

extern int obpl_parser_check_stack_overflow();

int get_deep_copy_size(const ParseNode *node, int64_t *size);
int deep_copy_parse_node(void *malloc_pool, const ParseNode *src, ParseNode *dst);

/// convert x'42ab' to binary string
void ob_parse_binary(const char *src, int64_t len, char* dest);
int64_t ob_parse_binary_len(int64_t len);

// convert b'10010110' to binary string
// @pre dest buffer is enough
void ob_parse_bit_string(const char* src, int64_t len, char* dest);
int64_t ob_parse_bit_string_len(int64_t len);

// calculate hash value of syntax tree recursively
// @param [in] node         syntax tree root
// @return                  hash value of syntax tree
extern uint64_t parsenode_hash(const ParseNode *node, int *ret);
// compare syntax tree recursively
// @param [in] node1        first syntax tree
// @param [in] node2        second syntax tree
extern bool parsenode_equal(const ParseNode *node1, const ParseNode *node2, int *ret);

extern int64_t get_question_mark(ObQuestionMarkCtx *ctx, void *malloc_pool, const char *name);
extern int64_t get_question_mark_by_defined_name(ObQuestionMarkCtx *ctx, const char *name);

// compare ParseNode str_value_ to pattern
// @param [in] node        ParseNode
// @param [in] pattern     pattern_str
// @param [in] pat_len     length of pattern
extern bool nodename_equal(const ParseNode *node, const char *pattern, int64_t pat_len);

#define OB_NODE_CAST_TYPE_IDX 0
#define OB_NODE_CAST_COLL_IDX 1
#define OB_NODE_CAST_N_PREC_IDX 2
#define OB_NODE_CAST_N_SCALE_IDX 3
#define OB_NODE_CAST_NUMBER_TYPE_IDX 1
#define OB_NODE_CAST_C_LEN_IDX 1
#define OB_NODE_CAST_GEO_TYPE_IDX 1

typedef enum ObNumberParseType
{
  NPT_PERC_SCALE = 0,
  NPT_STAR_SCALE,
  NPT_STAR,
  NPT_PERC,
  NPT_EMPTY,
} ObNumberParseType;

#ifndef SQL_PARSER_COMPILATION
bool check_stack_overflow_c();
//查找外部pl变量的接口，获取变量在外部符号表中的下标，定义在ob_pl_stmt.cpp中
int lookup_pl_symbol(const void *pl_ns, const char *symbol, size_t len, int64_t *find_idx);
#endif

typedef struct _ParserLinkNode
{
  struct _ParserLinkNode *next_;
  struct _ParserLinkNode *prev_;
  void *val_;
} ParserLinkNode;

ParserLinkNode *new_link_node(void *malloc);

typedef enum ObTranslateCharset
{
  TRANSLATE_CHAR_CS = 0,
  TRANSLATE_NCHAR_CS = 1,
} ObTranslateCharset;

#ifdef __cplusplus
}
#endif

#endif //OCEANBASE_SQL_PARSER_PARSE_NODE_H_