oceanbase/src/sql/resolver/ob_stmt.cpp

/**
 * 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.
 */

#define USING_LOG_PREFIX SQL_RESV
#include "sql/resolver/ob_stmt.h"
#include "sql/resolver/dml/ob_select_stmt.h"
#include "sql/resolver/ob_stmt_resolver.h"
//#include "sql/resolver/ob_schema_checker.h"
#include "share/schema/ob_table_schema.h"
#include "share/inner_table/ob_inner_table_schema.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "sql/session/ob_sql_session_info.h"
#include "share/schema/ob_column_schema.h"
#include "sql/ob_sql_context.h"
#include "common/ob_field.h"
#include "sql/parser/ob_parser.h"
#include "common/sql_mode/ob_sql_mode.h"

namespace oceanbase
{
using namespace common;
using namespace share::schema;
namespace sql
{

// query_ctx_ no deep_copy
// child_stmts_ no deep_copy
// parent_stmt no deep_copy
// synonym_is_store no deep_copy
int ObStmt::assign(const ObStmt &other)
{
  int ret = OB_SUCCESS;
  stmt_type_ = other.stmt_type_;
  query_ctx_ = other.query_ctx_;
  stmt_id_ = other.stmt_id_;
  return ret;
}

int ObStmt::deep_copy(const ObStmt &other)
{
  int ret = OB_SUCCESS;
  if (OB_FAIL(assign(other))) {
    LOG_WARN("failed to deep copy stmt", K(ret));
  } else { /*do nothing*/ }
  return ret;
}

bool ObStmt::get_fetch_cur_time() const
{
  return query_ctx_->fetch_cur_time_;
}

int64_t ObStmt::get_pre_param_size() const
{
  return query_ctx_->question_marks_count_;
}

void ObStmt::increase_question_marks_count()
{
  ++query_ctx_->question_marks_count_;
}

int64_t ObStmt::get_question_marks_count() const
{
  return query_ctx_->question_marks_count_;
}

int ObStmt::add_calculable_item(const ObHiddenColumnItem &calcuable_item)
{
  increase_question_marks_count();
  return query_ctx_->calculable_items_.push_back(calcuable_item);
}

const ObIArray<ObHiddenColumnItem> &ObStmt::get_calculable_exprs() const
{
  return query_ctx_->calculable_items_;
}

common::ObIArray<ObHiddenColumnItem> &ObStmt::get_calculable_exprs()
{
  return query_ctx_->calculable_items_;
}

int ObStmt::set_stmt_id()
{
  int ret = OB_SUCCESS;
  if(NULL == query_ctx_) {
    stmt_id_ = OB_INVALID_STMT_ID;
  } else {
    stmt_id_ = query_ctx_->get_new_stmt_id();
    ret = query_ctx_->query_hint_.add_stmt_id_map(stmt_id_, get_stmt_type());
  }
  return ret;
}

int ObStmt::get_first_stmt(common::ObString &first_stmt)
{
  int ret = OB_SUCCESS;
  ObArenaAllocator allocator(ObModIds::OB_SQL_PARSER);
  ObSEArray<ObString, 1> queries;
  ObMPParseStat parse_stat;
  ObParser parser(allocator, DEFAULT_OCEANBASE_MODE);
  if (OB_ISNULL(query_ctx_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("query ctx is null", K(ret));
  } else if (OB_FAIL(parser.split_multiple_stmt(query_ctx_->get_sql_stmt(), queries, parse_stat,
                                         true /* return the first stmt */))) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("Get first statement from multiple statements failed", K(ret));
  } else if (0 == queries.count()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("Get non-statement from multiple statements", K(ret));
  } else {
    first_stmt = queries.at(0);
  }
  return ret;
}

ObStmt::~ObStmt()
{
}

int ObStmt::add_global_dependency_table(const ObSchemaObjVersion &dependency_table)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(get_query_ctx())) {
    ret = OB_NOT_INIT;
    LOG_WARN("query_ctx is null");
  } else {
    bool is_found = false;
    for (int64_t i = 0; OB_SUCC(ret) && !is_found && i < get_query_ctx()->global_dependency_tables_.count(); ++i) {
      const ObSchemaObjVersion &obj_version = get_query_ctx()->global_dependency_tables_.at(i);
      //此处需要判断是否显示给db名，因为同名表情况对于指定db和不指定db在plan cache中处理不一样
      if (obj_version.get_object_id() == dependency_table.get_object_id()
          && obj_version.object_type_ == dependency_table.object_type_
          && obj_version.is_db_explicit() == dependency_table.is_db_explicit()) {
        is_found = true;
      }
    }
    if (OB_SUCC(ret) && !is_found) {
      ret = get_query_ctx()->global_dependency_tables_.push_back(dependency_table);
    }
  }
  return ret;
}


const ObIArray<ObSchemaObjVersion> *ObStmt::get_global_dependency_table() const
{
  const ObIArray<ObSchemaObjVersion> *ret = NULL;
  if (query_ctx_ != NULL) {
    ret = &(query_ctx_->global_dependency_tables_);
  }
  return ret;
}

ObIArray<share::schema::ObSchemaObjVersion> *ObStmt::get_global_dependency_table()
{
  ObIArray<ObSchemaObjVersion> *ret = NULL;
  if (query_ctx_ != NULL) {
    ret = &(query_ctx_->global_dependency_tables_);
  }
  return ret;
}


int ObStmt::add_ref_obj_version(const uint64_t dep_obj_id,
                                const uint64_t dep_db_id,
                                const ObObjectType dep_obj_type,
                                const ObSchemaObjVersion &ref_obj_version,
                                common::ObIAllocator &allocator)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(get_query_ctx())) {
    ret = OB_NOT_INIT;
    LOG_WARN("query_ctx is null");
  } else if (OB_FAIL(get_query_ctx()->reference_obj_tables_.add_ref_obj_version(
             dep_obj_id, dep_db_id, dep_obj_type, ref_obj_version, allocator))) {
    LOG_WARN("failed to add reference obj version", K(ret));
  }
  return ret;
}

const ObReferenceObjTable *ObStmt::get_ref_obj_table() const
{
  const ObReferenceObjTable *ret = nullptr;
  if (query_ctx_ != nullptr) {
    ret = &(query_ctx_->reference_obj_tables_);
  }
  return ret;
}

ObReferenceObjTable *ObStmt::get_ref_obj_table()
{
  ObReferenceObjTable *ret = nullptr;
  if (query_ctx_ != nullptr) {
    ret = &(query_ctx_->reference_obj_tables_);
  }
  return ret;
}

void ObStmtFactory::destory()
{
  DLIST_FOREACH_NORET(node, stmt_store_.get_obj_list()) {
    if (node != NULL && node->get_obj() != NULL) {
      node->get_obj()->~ObStmt();
    }
  }
  stmt_store_.destroy();
  if (query_ctx_ != NULL) {
    query_ctx_->~ObQueryCtx();
    query_ctx_ = NULL;
  }
}

ObQueryCtx *ObStmtFactory::get_query_ctx()
{
  void *ptr = NULL;
  if (NULL == query_ctx_) {
    if ((ptr = allocator_.alloc(sizeof(ObQueryCtx))) != NULL) {
      query_ctx_ = new(ptr) ObQueryCtx();
    } else {
      LOG_WARN_RET(OB_ALLOCATE_MEMORY_FAILED, "create query ctx failed", "query_ctx size", sizeof(ObQueryCtx));
    }
  }
  return query_ctx_;
}

int ObStmtFactory::free_stmt(ObSelectStmt *stmt)
{
  int ret = OB_SUCCESS;
  ObObjNode<ObStmt*> *del_node = NULL;
  DLIST_FOREACH_NORET(node, stmt_store_.get_obj_list()) {
    if (node != NULL && node->get_obj() == stmt) {
      del_node = node;
      break;
    }
  }
  if (OB_SUCC(ret)) {
    if (OB_ISNULL(stmt_store_.get_obj_list().remove(del_node))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("node is not found", K(ret));
    } else if (OB_FAIL(free_list_.store_obj(stmt))) {
      LOG_WARN("failed to store stmt", K(ret));
    } else {
      stmt->~ObSelectStmt();
    }
  }
  return ret;
}

template<>
int ObStmtFactory::create_stmt<ObSelectStmt>(ObSelectStmt *&stmt)
{
  int ret = common::OB_SUCCESS;
  void *ptr = NULL;
  if (free_list_.get_obj_list().is_empty()) {
    ptr = allocator_.alloc(sizeof(ObSelectStmt));
  } else {
    stmt = free_list_.get_obj_list().remove_first()->get_obj();
    ptr = stmt;
  }
  stmt = NULL;
  if (OB_UNLIKELY(NULL == ptr)) {
    ret = common::OB_ALLOCATE_MEMORY_FAILED;
    SQL_RESV_LOG(ERROR, "no more memory to stmt");
  } else {
    stmt = new(ptr) ObSelectStmt();
    if (OB_FAIL(stmt_store_.store_obj(stmt))) {
      SQL_RESV_LOG(WARN, "store stmt failed", K(ret));
      stmt->~ObSelectStmt();
      stmt = NULL;
    } else if (OB_FAIL(stmt->init_stmt(table_hash_allocator_, wrapper_allocator_))) {
      LOG_WARN("failed to init tables hash", K(ret));
    }
  }
  return ret;
}

}  // namespace sql
}  // namespace oceanbase