oceanbase/src/sql/parser/parse_node.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 "sql/parser/parse_node.h"
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "lib/alloc/alloc_assist.h"
#include "sql/parser/parse_malloc.h"
#include "sql/parser/parse_node_hash.h"
#include "sql/parser/parse_define.h"
#include "sql/parser/sql_parser_base.h"
extern const char *get_type_name(int type);

#ifdef SQL_PARSER_COMPILATION
#include "sql/parser/parser_proxy_func.h"
#endif // SQL_PARSER_COMPILATION

int count_child(ParseNode *root, void *malloc_pool, int *count);

//merge_child:if succ ,return 0, else return 1
int merge_child(ParseNode *node, void *malloc_pool, ParseNode *source_tree, int *index);

void destroy_tree(ParseNode *root)
{
  (void)root;
  /*
  if (OB_UNLIKELY(NULL == root)) {
    //do nothing
  } else {
    int64_t i = 0;
    if (root->num_child_ > 0) {
      if (OB_UNLIKELY(NULL == root->children_)) {
        (void)fprintf(stderr, "ERROR children of root is NULL\n");
      } else {
        for (; i < root->num_child_; ++i) {
          destroy_tree(root->children_[i]);
          root->children_[i] = NULL;
        }
        parse_free(root->children_);
        root->children_ = NULL;
      }
    }
    if (NULL != root->str_value_) {
      parse_free((char *)root->str_value_);
      root->str_value_ = NULL;
    }
    parse_free(root);
    }*/
}

int get_deep_copy_size(const ParseNode *node, int64_t *size)
{
  int ret = OB_PARSER_SUCCESS;
  if (OB_UNLIKELY(NULL == node)) {
    ret = OB_PARSER_ERR_UNEXPECTED;
    (void)fprintf(stderr, "ERROR node is null\n");
  } else if (OB_UNLIKELY(NULL == size)) {
    ret = OB_PARSER_ERR_UNEXPECTED;
    (void)fprintf(stderr, "ERROR size is null\n");
  } else {
    *size += sizeof(ParseNode);
    if (node->str_len_ > 0 && node->str_value_ != NULL) {
      *size += node->str_len_ + 1;
    }
    if (node->text_len_ > 0 && node->raw_text_ != NULL) {
      *size += node->text_len_ + 1;
    }
    if (node->num_child_ > 0) {
      if (OB_UNLIKELY(NULL == node->children_)) {
        ret = OB_PARSER_ERR_UNEXPECTED;
        (void)fprintf(stderr, "ERROR children is null\n");
      } else {
        *size += (sizeof(ParseNode*) * node->num_child_);
      }
      for (int64_t i = 0; OB_PARSER_SUCCESS == ret && i < node->num_child_; ++i) {
        ParseNode *child_node = node->children_[i];
        if (OB_UNLIKELY(NULL == child_node)) {
          ret = OB_PARSER_ERR_UNEXPECTED;
          (void)fprintf(stderr, "ERROR child node is null\n");
        } else if (OB_PARSER_SUCCESS != (ret = get_deep_copy_size(child_node, size))) {
          (void)fprintf(stderr, "ERROR failed to get deep copy size\n");
        }
      }
    }
  }
  return ret;
}

int deep_copy_parse_node(void *malloc_pool, const ParseNode *src_node, ParseNode *dst_node)
{
  int ret = OB_PARSER_SUCCESS;
  if (OB_UNLIKELY(NULL == src_node) || OB_UNLIKELY(NULL == dst_node)) {
    ret = OB_PARSER_ERR_UNEXPECTED;
    (void)fprintf(stderr, "ERROR node is null\n");
  } else if (OB_UNLIKELY(NULL == malloc_pool)) {
    ret = OB_PARSER_ERR_UNEXPECTED;
    (void)fprintf(stderr, "ERROR malloc pool is null\n");
  } else {
    dst_node->type_ = src_node->type_;
    dst_node->num_child_ = src_node->num_child_;
    dst_node->param_num_ = src_node->param_num_;
    dst_node->flag_ = src_node->flag_;
    dst_node->value_ = src_node->value_;
    dst_node->pos_ = src_node->pos_;
    dst_node->stmt_loc_ = src_node->stmt_loc_;
    dst_node->raw_param_idx_ = src_node->raw_param_idx_;
  #ifdef SQL_PARSER_COMPILATION
    dst_node->token_off_= src_node->token_off_;
    dst_node->token_len_ = src_node->token_len_;
  #endif
    if (src_node->str_len_ > 0 && src_node->str_value_ != NULL) {
      char *buf = NULL;
      if (OB_UNLIKELY(NULL == (buf = (char *)parser_alloc(malloc_pool, src_node->str_len_ + 1)))) {
        ret = OB_PARSER_ERR_NO_MEMORY;
        (void)fprintf(stderr, "ERROR failed to allocate memory\n");
      } else {
        dst_node->str_len_ = src_node->str_len_;
        MEMCPY(buf, src_node->str_value_, dst_node->str_len_);
        buf[dst_node->str_len_] = '\0';
        dst_node->str_value_ = buf;
      }
    }
    if (OB_PARSER_SUCCESS == ret && src_node->text_len_ > 0 && src_node->raw_text_ != NULL) {
      char *buf = NULL;
      if (OB_UNLIKELY(NULL == (buf = (char *)parser_alloc(malloc_pool, src_node->text_len_ + 1)))) {
        ret = OB_PARSER_ERR_NO_MEMORY;
        (void)fprintf(stderr, "ERROR failed to allocate memory\n");
      } else {
        dst_node->text_len_ = src_node->text_len_;
        dst_node->pos_ = src_node->pos_;
        MEMCPY(buf, src_node->raw_text_, dst_node->text_len_);
        buf[dst_node->text_len_] = '\0';
        dst_node->raw_text_ = buf;
      }
    }
    if (OB_PARSER_SUCCESS == ret && src_node->num_child_ > 0) {
      if (OB_UNLIKELY(NULL == src_node->children_)) {
        ret = OB_PARSER_ERR_UNEXPECTED;
        (void)fprintf(stderr, "ERROR children is null\n");
      } else if (OB_UNLIKELY(NULL == (dst_node->children_ = (ParseNode **)parser_alloc(
                                      malloc_pool, sizeof(ParseNode*) * src_node->num_child_)))) {
        ret = OB_PARSER_ERR_NO_MEMORY;
        (void)fprintf(stderr, "ERROR failed to allocate memory\n");
      }
      for (int64_t i = 0; OB_PARSER_SUCCESS == ret && i < src_node->num_child_; ++i) {
        ParseNode *tmp_node = NULL;
        ParseNode *child_node = src_node->children_[i];
        if (OB_UNLIKELY(NULL == child_node)) {
          ret = OB_PARSER_ERR_UNEXPECTED;
          (void)fprintf(stderr, "ERROR child node is null\n");
        } else if (OB_UNLIKELY(NULL == (tmp_node =
                  (ParseNode *)parser_alloc(malloc_pool, sizeof(ParseNode))))) {
          ret = OB_PARSER_ERR_NO_MEMORY;
          (void)fprintf(stderr, "ERROR failed to allocate memory\n");
        } else if (OB_PARSER_SUCCESS != (ret = deep_copy_parse_node(malloc_pool, child_node, tmp_node))) {
          (void)fprintf(stderr, "ERROR failed to deep copy parse node\n");
        } else {
          dst_node->children_[i] = tmp_node;
        }
      }
    }
  }
  return ret;
}

ParseNode *new_node(void *malloc_pool, ObItemType type, int num)
{
  // the mem alloced by parse_malloc has been memset;
  ParseNode *node = (ParseNode *)parse_malloc(sizeof(ParseNode), malloc_pool);
  if (OB_UNLIKELY(NULL == node)) {
    (void)printf("malloc memory failed\n");
  } else {
    node->type_ = type;
    node->num_child_ = num;
    node->value_ = INT64_MAX;
    node->pl_str_off_ = -1;
#ifdef SQL_PARSER_COMPILATION
    node->token_off_ = -1;
    node->token_len_ = -1;
#endif
    if (num > 0) {
      int64_t alloc_size = sizeof(ParseNode *) * num ;
      node->children_ = (ParseNode **)parse_malloc(alloc_size, malloc_pool);
      if (OB_UNLIKELY(NULL == node->children_)) {
        parse_free(node);
        node = NULL;
      }
    } else {
      node->children_ = NULL;
    }
  }
  return node;
}

int count_child(ParseNode *root, void *malloc_pool, int *count)
{
  int ret = OB_PARSER_SUCCESS;
  ParserLinkNode *stack_top = NULL;
  if (NULL == count) {
    ret = OB_PARSER_ERR_UNEXPECTED;
    (void)fprintf(stderr, "ERROR invalid parameter ret=%d\n", ret);
  } else if (NULL == root) {
    *count = 0;
  } else if (NULL == (stack_top = new_link_node(malloc_pool))) {
    ret = OB_PARSER_ERR_NO_MEMORY;
    (void)fprintf(stderr, "ERROR failed to malloc memory\n");
  } else {
    *count = 0;
    stack_top->val_ = root;

    do {
      ParseNode *tree = NULL;
      if (NULL == stack_top || NULL == (tree = (ParseNode *)stack_top->val_)) {
        ret = OB_PARSER_ERR_UNEXPECTED;
        (void)fprintf(stderr, "ERROR invalid null argument\n");
      } else {
        stack_top = stack_top->next_;
      }

      if (OB_PARSER_SUCCESS != ret) {
      } else if (T_LINK_NODE != tree->type_) {
        *count += 1;
      } else if (tree->num_child_ <= 0) {
        // do nothing
      } else {
        if (NULL == tree->children_) {
          ret = OB_PARSER_ERR_UNEXPECTED;
          (void)fprintf(stderr, "ERROR invalid null children\n");
        }
        ParserLinkNode *tmp_node = NULL;
        for (int64_t i = tree->num_child_ - 1; OB_PARSER_SUCCESS == ret && i >= 0; i--) {
          ParseNode *child = tree->children_[i];
          if (NULL == child) {
            // do nothing
          } else if (NULL == (tmp_node = new_link_node(malloc_pool))) {
            ret = OB_PARSER_ERR_NO_MEMORY;
            (void)fprintf(stderr, "ERROR failed to allocate memory\n");
          } else {
            tmp_node->val_ = child;
            tmp_node->next_ = stack_top;
            stack_top = tmp_node;
          }
        } // for end
      }
    } while (OB_PARSER_SUCCESS == ret && NULL != stack_top);
  }
  return ret;
}

//merge_child:if succ ,return 0, else return 1
int merge_child(ParseNode *node, void *malloc_pool, ParseNode *source_tree, int *index)
{
  int ret = 0;
  ParserLinkNode *stack_top = NULL;
  if (OB_UNLIKELY(NULL == node || NULL == index)) {
    ret = OB_PARSER_ERR_UNEXPECTED;
    (void)fprintf(stderr, "ERROR node%p or index:%p is NULL\n", node, index);
  } else if (NULL == source_tree) {
    //do nothing
  } else if (NULL == (stack_top = new_link_node(malloc_pool))) {
    ret = OB_PARSER_ERR_NO_MEMORY;
    (void)fprintf(stderr, "ERROR failed to malloc memory\n");
  } else {
    stack_top->val_ = source_tree;

    do {
      ParseNode *tree = NULL;
      if (NULL == stack_top || NULL == (tree = (ParseNode *)stack_top->val_)) {
        ret = OB_PARSER_ERR_UNEXPECTED;
        (void)fprintf(stderr, "ERROR invalid null argument\n");
      } else {
        // pop stack
        stack_top = stack_top->next_;
      }
      if (OB_PARSER_SUCCESS != ret) {
        // do nothing
      } else if (T_LINK_NODE != tree->type_) {
        if (OB_UNLIKELY(*index < 0 || *index >= node->num_child_)) {
          ret = OB_PARSER_ERR_UNEXPECTED;
          (void)fprintf(stderr, "ERROR invalid index: %d, num_child:%d\n tree: %d",
                        *index, node->num_child_, tree->type_);
        } else if (NULL == node->children_) {
          ret = OB_PARSER_ERR_UNEXPECTED;
          (void)fprintf(stderr, "ERROR invalid null children pointer\n");
        } else {
          node->children_[*index] = tree;
          ++(*index);
        }
      } else if (tree->num_child_ <= 0) {
        // do nothing
      } else if (NULL == tree->children_) {
        ret = OB_PARSER_ERR_UNEXPECTED;
        (void)fprintf(stderr, "ERROR invalid children pointer\n");
      } else {
        ParserLinkNode *tmp_node = NULL;
        for (int64_t i = tree->num_child_ - 1; OB_PARSER_SUCCESS == ret && i >= 0; i--) {
          if (NULL == tree->children_[i]) {
            // do nothing
          } else if (NULL == (tmp_node = new_link_node(malloc_pool))) {
            ret = OB_PARSER_ERR_NO_MEMORY;
            (void)fprintf(stderr, "ERROR failed to malloc memory\n");
          } else {
            // push stack
            tmp_node->val_ = tree->children_[i];
            tmp_node->next_ = stack_top;
            stack_top = tmp_node;
          }
        } // for end
      }
    } while (OB_PARSER_SUCCESS == ret && (stack_top != NULL));
  }
  return ret;
}

ParseNode *merge_tree(void *malloc_pool, int *fatal_error,
                      ObItemType node_tag, ParseNode *source_tree)
{
  ParseNode *node = NULL;
  ParseNode *ret_node = NULL;
  if (OB_UNLIKELY(NULL == malloc_pool) || OB_UNLIKELY(NULL == fatal_error)) {
    (void)fprintf(stderr, "ERROR parser result is NULL\n");
  } else if (NULL == source_tree) {
    //source_tree may be NULL, do nothing
  } else {
    int index = 0;
    int num = 0;
    int tmp_ret = 0;
    if (OB_UNLIKELY(OB_PARSER_SUCCESS != (tmp_ret = count_child(source_tree,
                                                                malloc_pool, &num)))) {
      (void)fprintf(stderr, "ERROR fail to , count child num code : %d\n", tmp_ret);
      *fatal_error = tmp_ret;
    } else if (OB_LIKELY(NULL != (node = new_node(malloc_pool, node_tag, num)))) {
      if (OB_UNLIKELY(OB_PARSER_SUCCESS != (tmp_ret = merge_child(node,
                                                                  malloc_pool,
                                                                  source_tree,
                                                                  &index)))) {
        (void)fprintf(stderr, "ERROR fail to merge_child, error code : %d\n", tmp_ret);
        *fatal_error = tmp_ret;
      } else if (index != num) {
        (void)fprintf(stderr, "ERROR index:%d is not equal to num:%d\n", index, num);
      } else {
        ret_node = node;
      }
    } else {
      *fatal_error = OB_PARSER_ERR_NO_MEMORY;
    }
  }
  return ret_node;
}

ParseNode *new_terminal_node(void *malloc_pool, ObItemType type)
{
  int children_num = 0;
  return new_node(malloc_pool, type, children_num);
}

ParseNode *new_non_terminal_node(void *malloc_pool, ObItemType node_tag, int num, ...)
{
  ParseNode *ret_node = NULL;
  if (OB_UNLIKELY(num <= 0)) {
    (void)fprintf(stderr, "ERROR invalid num:%d\n", num);
  } else {
    int32_t i = 0;
    va_list va;
    ret_node = new_node(malloc_pool, node_tag, num);
    if (OB_LIKELY(NULL != ret_node)) {
      va_start(va, num);
      for (; i < num; ++i) {
        ret_node->children_[i] = va_arg(va, ParseNode *);
      }
      va_end(va);
    }
  }
  return ret_node;
}

char *copy_expr_string(ParseResult *p, int expr_start, int expr_end)
{
  char *expr_string = NULL;
  if (OB_UNLIKELY(NULL == p)) {
    (void)fprintf(stderr, "ERROR parser result is NULL\n");
  } else if (OB_UNLIKELY(NULL == p->input_sql_)) {
    (void)fprintf(stderr, "ERROR input sql is NULL\n");
  } else if (OB_UNLIKELY(expr_start < 0 || expr_end < 0 || expr_end < expr_start)) {
    (void)fprintf(stderr, "ERROR invalid argument, expr_start:%d, expr_end:%d\n", expr_start, expr_end);
  } else {
    int len = expr_end - expr_start + 1;
    expr_string = (char *)parse_malloc(len + 1, p->malloc_pool_);
    if (OB_UNLIKELY(NULL == expr_string)) {
     (void)printf("malloc memory failed\n");
    } else {
      memmove(expr_string, p->input_sql_ + expr_start - 1, len);
      expr_string[len] = '\0';
    }
  }
  return expr_string;
}
int store_prentthese_info(int left, int right, ParseResult *result)
{
  int ret = 0;
  if (OB_UNLIKELY(NULL == result)) {
    ret = -1;
    (void)fprintf(stderr, "ERROR invalid parentheses pointer\n");
  } else {
    ParenthesesOffset *object =
      (ParenthesesOffset *)malloc_parentheses_info(sizeof(ParenthesesOffset), result->malloc_pool_);
    if (OB_UNLIKELY(NULL == object)) {
      ret = OB_PARSER_ERR_NO_MEMORY;
      (void)fprintf(stderr, "ERROR invalid parentheses pointer\n");
    } else {
      object->left_parentheses_ = left;
      object->right_parentheses_ = right;
      object->next_ = NULL;
      if (NULL == result->ins_multi_value_res_->ref_parentheses_) {
        result->ins_multi_value_res_->ref_parentheses_ = object;
        result->ins_multi_value_res_->values_count_ = 1;
      } else {
        result->ins_multi_value_res_->tail_parentheses_->next_ = object;
        result->ins_multi_value_res_->values_count_++;
      }
      result->ins_multi_value_res_->tail_parentheses_ = object;
    }
  }
  return ret;
}

unsigned char escaped_char(unsigned char c, int *with_back_slash)
{
  *with_back_slash = 0;
  switch (c) {
  case 'n':
    return '\n';
  case 't':
    return '\t';
  case 'r':
    return '\r';
  case 'b':
    return '\b';
  case '0':
    return '\0';
  case 'Z':
    return '\032';
  case '_':
  case '%':
    *with_back_slash = 1;
    return c;
  default:
    return c;
  }
}

///* quote_type: 0 - single quotes; 1 - double quotation marks */
//int64_t ob_parse_string(const char *src, char *dest, int64_t len, int quote_type)
//{
//  int64_t i;
//  int64_t index = 0;
//  int with_back_slash = 1;
//  for (i = 0; i < len; ++i) {
//    unsigned char c = src[i];
//    if (c == '\\') {
//      if (i < len - 1) {
//        c = src[++i];
//      } else {
//        break;
//      }
//      c = escaped_char(c, &with_back_slash);
//      if (with_back_slash)
//      {
//        dest[index++] = '\\';
//      }
//    } else if (quote_type == 0 && c == '\'' && i + 1 < len && src[i + 1] == '\'') {
//      ++i;
//    } else if (quote_type == 1 && c == '"' && i + 1 < len && src[i + 1] == '"') {
//      ++i;
//    }
//    dest[index++] = c;
//  }
//  assert(index <= len);
//  dest[index] = '\0';
//  return index;
//}

static char char_int(char c)
{
  return (c >= '0' && c <= '9' ? c-'0': (c >= 'A' && c <= 'Z' ? c - 'A' + 10 : c - 'a' + 10));
}

int64_t ob_parse_binary_len(int64_t len)
{
  return (len + 1) / 2;
}

void ob_parse_binary(const char *src, int64_t len, char *dest)
{
  if (OB_UNLIKELY(NULL == src || len <= 0 || NULL == dest)) {
    //do nothing
  } else {
    bool is_odd = false;
    if (len > 0 && len % 2 != 0)
    {
      *dest = char_int(src[0]);
      ++src;
      ++dest;
      is_odd = true;
    }
    if (len == 1) {
      //do nothing.
    } else {
      //for odd number, we have copy the first char,  so we should minus 2;
      const char *end = src + len - (is_odd ? 2 : 1);
      for (; src <= end; src += 2)
      {
        *dest = (char)(16*char_int(src[0]) + char_int(src[1]));
        ++dest;
      }
    }
  }
}

int64_t ob_parse_bit_string_len(int64_t len)
{
  return (len + 7) / 8;
}

void ob_parse_bit_string(const char* src, int64_t len, char* dest)
{
  if (OB_UNLIKELY(NULL == src || len <= 0 || NULL == dest)) {
    //do nothing
  } else {
    const char* end = src + len -1;
    char* dest_end = dest + ob_parse_bit_string_len(len) - 1;
    if (len > 0)
    {
      unsigned char c = 0;
      unsigned int one_bit = 1;
      for ( ; end >= src; --end)
      {
        if (256 == one_bit)         /* one byte ready */
        {
          *dest_end = c;
          --dest_end;
          c = 0;
          one_bit = 1;
        }
        if ('1' == *end)
        {
          c |= one_bit;
        }
        one_bit <<= 1;
      } /* end for */
      *dest_end = c;              /* the first byte */
    }
  }
}

char *str_tolower(char *buff, int64_t len)
{
  if (OB_LIKELY(NULL != buff)) {
    char *ptr = buff;
	char *end = buff + len;
    unsigned char ch = *ptr;
    while (ptr != end) {
      ch = *ptr;
      if (ch >= 'A' && ch <= 'Z') {
        ch += 'a' - 'A';
      } else if (ch >= 0x80 && isupper(ch)) {
        ch = tolower(ch);
      }
      *ptr = ch;
      ptr++;
    }
  }
  return buff;
}

char *str_toupper(char *buff, int64_t len)
{
  if (OB_LIKELY(NULL != buff)) {
    char *ptr = buff;
	char *end = buff + len;
    unsigned char ch = *ptr;
    while (ptr != end) {
      ch = *ptr;
      if (ch >= 'a' && ch <= 'z') {
        ch -= 'a' - 'A';
      } else if (ch >= 0x80 && islower(ch)) {
        ch = toupper(ch);
      }
      *ptr = ch;
      ptr++;
    }
  }
  return buff;
}

int64_t str_remove_space(char *buff, int64_t len)
{
  int64_t length = 0;
  if (OB_LIKELY(NULL != buff)) {
    for (int i = 0; i < len; i++) {
      if (!isspace(buff[i])) {
        buff[length++] = buff[i];
      }
    }
  }
  return length;
}

// calculate hash value of syntax tree recursively
// every member of ParseNode is calculated using murmurhash
uint64_t parsenode_hash(const ParseNode *node, int *ret)
{
  uint64_t hash_val = 0;
  if (check_stack_overflow_c()) {
    (void)fprintf(stderr, "ERROR stack overflow in recursive function\n");
    if (ret) {
      *ret = OB_PARSER_ERR_SIZE_OVERFLOW;
    }
  } else if (OB_LIKELY(NULL != node)) {
    hash_val = murmurhash(&node->type_, sizeof(node->type_), hash_val);
    hash_val = murmurhash(&node->value_, sizeof(node->value_), hash_val);
    hash_val = murmurhash(&node->str_len_, sizeof(node->str_len_), hash_val);
    if (NULL != node->str_value_) {
      hash_val = murmurhash(node->str_value_, (int32_t)node->str_len_, hash_val);
    }

    uint64_t child_hash_val = 0;
    int32_t i = 0;
    if (node->num_child_ > 0) {
      if (OB_UNLIKELY(NULL == node->children_)) {
        (void)fprintf(stderr, "ERROR children of node is NULL\n");
      } else {
        for (; i < node->num_child_; ++i) {
          if (NULL != node->children_[i]) {
            child_hash_val = parsenode_hash(node->children_[i], ret);
            if (ret && OB_PARSER_ERR_SIZE_OVERFLOW == *ret) {
              break;
            }
            hash_val = murmurhash(&child_hash_val, sizeof(child_hash_val), hash_val);
          }
        }
      }
    }
  }
  return hash_val;
}

// compare syntax tree recursively
// every member of ParseNode is compared
bool parsenode_equal(const ParseNode *lnode, const ParseNode *rnode, int *ret)
{
  bool result = true;
  if (check_stack_overflow_c()) {
    (void)fprintf(stderr, "ERROR stack overflow in recursive function\n");
    if (ret) {
      *ret = OB_PARSER_ERR_SIZE_OVERFLOW;
    }
  } else if (NULL == lnode && NULL == rnode) {
    result = true;
  } else if ((NULL == lnode && NULL != rnode)
             || (NULL != lnode && NULL == rnode)) {
    result = false;
  } else {
    if (lnode->type_ != rnode->type_
        || lnode->value_ != rnode->value_
        || lnode->str_len_ != rnode->str_len_
        || lnode->num_child_ != rnode->num_child_) {
      result = false;
    } else {
      if (NULL == lnode->str_value_ && NULL == rnode->str_value_) {
        result = true;
      } else if ((NULL == lnode->str_value_ && NULL != rnode->str_value_)
                 || (NULL != lnode->str_value_ && NULL == rnode->str_value_ )) {
        result = false;
      } else if (lnode->str_len_ != rnode->str_len_) {
        result = false;
      } else {
        // T_VARCHAR type: value_ is length, str_value_ is ptr
        // @ref ob_raw_expr.cpp
        if (0 != strncmp(lnode->str_value_, rnode->str_value_, lnode->str_len_)){
          result = false;
        }
      }
      if (result) {
        if (lnode->num_child_ > 0) {
          if (NULL == lnode->children_ || NULL == rnode->children_) {
            result = false;
          } else {
            int32_t i = 0;
            for (; result && i < lnode->num_child_; ++i) {
              result = parsenode_equal(lnode->children_[i], rnode->children_[i], ret);
              if (ret && OB_PARSER_ERR_SIZE_OVERFLOW == *ret) {
                break;
              }
            }
          }
        }
      }
    }
  }
  return result;
}

//根据名字寻找，找到后返回该名字的下标，找不到把名字加入并返回下标
int64_t get_question_mark(ObQuestionMarkCtx *ctx, void *malloc_pool, const char *name)
{
  int64_t idx = -1;
  if (OB_UNLIKELY(NULL == ctx || NULL == name)) {
    (void)fprintf(stderr, "ERROR question mark ctx or name is NULL\n");
  } else {
    if (NULL == ctx->name_ && 0 == ctx->capacity_) {
      ctx->capacity_ = MAX_QUESTION_MARK;
      // the errcode will be ignored here. TO BE FIXED.
      ctx->name_ = (char **)parse_malloc(sizeof(char*) * MAX_QUESTION_MARK, malloc_pool);
    }
    if (ctx->name_ != NULL) {
      bool valid_name = true;
      for (int64_t i = 0; valid_name && -1 == idx && i < ctx->count_; ++i) {
        if (NULL == ctx->name_[i]) {
          (void)fprintf(stderr, "ERROR name_ in question mark ctx is null\n");
          valid_name = false;
        } else if (0 == STRCASECMP(ctx->name_[i], name)) {
          idx = i;
        }
      }
      if (-1 == idx && valid_name) {
        if (ctx->count_ >= ctx->capacity_) {
          void *buf = parse_malloc(sizeof(char*) * (ctx->capacity_ * 2), malloc_pool);
          if (OB_UNLIKELY(NULL == buf)) {
            ctx->name_ = NULL;
            (void)printf("ERROR malloc memory failed\n");
          } else {
            MEMCPY(buf, ctx->name_, sizeof(char*) * ctx->capacity_);
            ctx->capacity_ *= 2;
            ctx->name_ = (char **)buf;
          }
        }
        if (ctx->name_ != NULL) {
          int64_t len = 0;
          ctx->name_[ctx->count_] = parse_strdup(name, malloc_pool, &len);
          idx = ctx->count_++;
        }
      }
    } else {
      (void)fprintf(stderr, "ERROR question mark name buffer is null\n");
    }
  }
  return idx;
}

int64_t get_question_mark_by_defined_name(ObQuestionMarkCtx *ctx, const char *name)
{
  int64_t idx = -1;
  if (OB_UNLIKELY(NULL == ctx || NULL == name)) {
    (void)fprintf(stderr, "ERROR question mark ctx or name is NULL\n");
  } else if (ctx->name_ != NULL) {
    for (int64_t i = 0; -1 == idx && i < ctx->count_; ++i) {
      if (NULL == ctx->name_[i]) {
        (void)fprintf(stderr, "ERROR name_ in question mark ctx is null\n");
      } else if (0 == STRCASECMP(ctx->name_[i], name)) {
        idx = i;
        break;
      }
    }
  } else {
    (void)fprintf(stderr, "ERROR name_ in question mark ctx is null\n");
  }
  return idx;
}

ParserLinkNode *new_link_node(void *malloc)
{
  ParserLinkNode *new_node = (ParserLinkNode *)parse_malloc(sizeof(ParserLinkNode), malloc);
  if (NULL == new_node) {
    (void)printf("ERROR malloc memory failed\n");
  } else {
    new_node->next_ = NULL;
    new_node->prev_ = NULL;
    new_node->val_ = NULL;
  }
  return new_node;
}

bool nodename_equal(const ParseNode *node, const char *pattern, int64_t pat_len)
{
  bool result = true;
  if (NULL == node || NULL == node->str_value_ || NULL == pattern || node->str_len_ != pat_len) {
    result = false;
  } else {
    result = true;
    for (int64_t i = 0; result && i < pat_len; ++i) {
      if (toupper(node->str_value_[i]) != toupper(pattern[i])) {
        result = false;
      }
    }
  }
  return result;
}