hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
db972bbeebcc10f0ded8d7414e50308f8d55cbec
oceanbase/src/sql/resolver/dml/ob_sql_hint.cpp
cqliang1995 43c435fe20 fix dblink transaction bug
2024-03-15 17:15:44 +00:00

2590 lines
99 KiB
C++
Raw Blame History

/**
* 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/dml/ob_sql_hint.h"
#include "sql/resolver/dml/ob_dml_stmt.h"
#include "sql/resolver/dml/ob_select_stmt.h"
#include "sql/optimizer/ob_log_plan.h"
#include "sql/rewrite/ob_transform_utils.h"
#include "common/ob_smart_call.h"
#include "sql/monitor/ob_sql_plan.h"
namespace oceanbase
{
using namespace common;
namespace sql
{
void ObQueryHint::reset()
{
cs_type_ = CS_TYPE_INVALID;
global_hint_.reset();
is_valid_outline_ = false;
user_def_outline_ = false;
outline_stmt_id_ = OB_INVALID_STMT_ID;
qb_hints_.reuse();
stmt_id_hints_.reuse();
trans_list_.reuse();
outline_trans_hints_.reuse();
used_trans_hints_.reuse();
qb_name_map_.reuse();
stmt_id_map_.reuse();
}
int ObQueryHint::create_hint_table(ObIAllocator *allocator, ObTableInHint *&table)
{
int ret = common::OB_SUCCESS;
table = NULL;
void *ptr = NULL;
if (OB_ISNULL(allocator)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected params", K(ret), K(allocator));
} else if (OB_ISNULL(ptr = allocator->alloc(sizeof(ObTableInHint)))) {
ret = common::OB_ALLOCATE_MEMORY_FAILED;
SQL_RESV_LOG(ERROR, "no more memory to create hint table");
} else {
table = new(ptr) ObTableInHint();
}
return ret;
}
int ObQueryHint::create_leading_table(ObIAllocator *allocator, ObLeadingTable *&table)
{
int ret = common::OB_SUCCESS;
table = NULL;
void *ptr = NULL;
if (OB_ISNULL(allocator)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected params", K(ret), K(allocator));
} else if (OB_ISNULL(ptr = allocator->alloc(sizeof(ObLeadingTable)))) {
ret = common::OB_ALLOCATE_MEMORY_FAILED;
SQL_RESV_LOG(ERROR, "no more memory to create leading table");
} else {
table = new(ptr) ObLeadingTable();
}
return ret;
}
int ObQueryHint::get_qb_name_source_hash_value(const ObString &src_qb_name,
const ObIArray<uint32_t> &src_hash_val,
uint32_t &hash_val)
{
int ret = OB_SUCCESS;
hash_val = 0;
if (OB_UNLIKELY(src_hash_val.empty())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected src_hash_val", K(ret), K(src_hash_val));
} else {
hash_val = src_hash_val.at(src_hash_val.count() - 1);
hash_val = fnv_hash2(src_qb_name.ptr(), src_qb_name.length(), hash_val);
}
return ret;
}
int ObQueryHint::set_outline_data_hints(const ObGlobalHint &global_hint,
const int64_t stmt_id,
const ObIArray<ObHint*> &hints)
{
int ret = OB_SUCCESS;
qb_hints_.reuse();
stmt_id_hints_.reuse();
trans_list_.reuse();
if (OB_FAIL(global_hint_.assign(global_hint))) {
LOG_WARN("failed to assign global hint.", K(ret));
} else if (OB_FAIL(append_hints(stmt_id, hints))) {
LOG_WARN("failed to assign global hint.", K(ret));
} else {
if (global_hint_.has_valid_opt_features_version()) {
is_valid_outline_ = true;
outline_stmt_id_ = stmt_id;
} else {
user_def_outline_ = true;
}
ObHint *cur_hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < hints.count(); ++i) {
if (OB_ISNULL(cur_hint = hints.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL.", K(ret), K(cur_hint));
} else if (cur_hint->is_transform_outline_hint()
&& OB_FAIL(trans_list_.push_back(cur_hint))) {
LOG_WARN("faild to push back hint.", K(ret));
}
}
LOG_DEBUG("finish add outline data hints");
}
return ret;
}
int ObQueryHint::append_hints(int64_t stmt_id,
const ObIArray<ObHint*> &hints)
{
int ret = OB_SUCCESS;
const ObHints *stmt_id_hints = get_stmt_id_hints(stmt_id);
ObHints *qb_hints = NULL;
ObHint *cur_hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < hints.count(); ++i) {
if (OB_ISNULL(cur_hint = hints.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL.", K(ret), K(cur_hint));
} else if (cur_hint->get_qb_name().empty()) {
if (NULL == (qb_hints = const_cast<ObHints*>(stmt_id_hints))) {
if (OB_ISNULL(qb_hints = stmt_id_hints_.alloc_place_holder())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("Allocate ObHints from array error", K(ret));
} else {
qb_hints->stmt_id_ = stmt_id;
stmt_id_hints = qb_hints;
}
}
} else if (NULL != (qb_hints = const_cast<ObHints*>(get_qb_hints(cur_hint->get_qb_name())))) {
/* do nothing */
} else if (OB_ISNULL(qb_hints = qb_hints_.alloc_place_holder())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("Allocate ObHints from array error", K(ret));
} else {
qb_hints->qb_name_ = cur_hint->get_qb_name();
}
if (OB_SUCC(ret) && OB_FAIL(qb_hints->hints_.push_back(cur_hint))) {
LOG_WARN("faild to push back hint.", K(ret));
}
}
return ret;
}
const ObHints *ObQueryHint::get_qb_hints(const ObString &qb_name) const
{
const ObHints *qb_hints = NULL;
for (int64_t i = 0; NULL == qb_hints && i < qb_hints_.count(); ++i) {
if (0 == qb_name.case_compare(qb_hints_.at(i).qb_name_)) {
qb_hints = &qb_hints_.at(i);
}
}
return qb_hints;
}
const ObHints *ObQueryHint::get_stmt_id_hints(int64_t stmt_id) const
{
const ObHints *qb_hints = NULL;
for (int64_t i = 0; NULL == qb_hints && i < stmt_id_hints_.count(); ++i) {
if (stmt_id_hints_.at(i).stmt_id_ == stmt_id) {
qb_hints = &stmt_id_hints_.at(i);
}
}
return qb_hints;
}
int ObQueryHint::add_stmt_id_map(const int64_t stmt_id, stmt::StmtType stmt_type)
{
int ret = OB_SUCCESS;
QbNames *qb_names = NULL;
if (OB_INVALID_STMT_ID == stmt_id) {
/* do nothing */
} else if (OB_UNLIKELY(stmt_id_map_.count() != stmt_id)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("exists valid stmt id not added before", K(ret), K(stmt_id),
K(stmt_type), K(stmt_id_map_.count()));
} else if (OB_ISNULL(qb_names = stmt_id_map_.alloc_place_holder())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("allocate QbNames from array error", K(ret));
} else {
qb_names->stmt_type_ = stmt_type;
}
return ret;
}
int ObQueryHint::set_stmt_id_map_info(const ObDMLStmt &stmt, ObString &qb_name)
{
int ret = OB_SUCCESS;
const int64_t stmt_id = stmt.get_stmt_id();
if (OB_UNLIKELY(0 > stmt_id || stmt_id_map_.count() <= stmt_id)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected stmt id for dml stmt", K(ret), K(stmt_id), K(stmt_id_map_.count()));
} else {
QbNames &qb_names = stmt_id_map_.at(stmt_id);
qb_names.stmt_type_ = stmt.get_stmt_type();
qb_names.is_set_stmt_ = stmt.is_set_stmt();
qb_names.is_from_hint_ = !qb_name.empty();
qb_names.qb_names_.reuse();
if (!qb_name.empty() && OB_FAIL(qb_names.qb_names_.push_back(qb_name))) {
LOG_WARN("fail to push back qb name", K(ret), K(qb_name));
}
}
return ret;
}
int ObQueryHint::check_and_set_params_from_hint(const ObResolverParams &params, const ObDMLStmt &stmt) const
{
int ret = OB_SUCCESS;
const ObSQLSessionInfo *session_info = NULL;
bool has_enable_param = false;
ObQueryCtx *query_ctx = NULL;
if (OB_ISNULL(session_info = params.session_info_)
|| OB_ISNULL(query_ctx = params.query_ctx_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(session_info), K(query_ctx));
} else if (T_NONE_SCOPE != params.hidden_column_scope_ &&
OB_FAIL(global_hint_.opt_params_.has_enable_opt_param(ObOptParamHint::OptParamType::HIDDEN_COLUMN_VISIBLE, has_enable_param))) {
LOG_WARN("failed to check has enable opt param", K(ret));
} else if (OB_UNLIKELY(T_NONE_SCOPE != params.hidden_column_scope_ && !has_enable_param)) {
ret = OB_ERR_BAD_FIELD_ERROR;
LOG_WARN("hidden columns not allowed", K(ret));
ObString column_name(OB_HIDDEN_PK_INCREMENT_COLUMN_NAME);
ObString scope_name = ObString::make_string(get_scope_name(params.hidden_column_scope_));
LOG_USER_ERROR(OB_ERR_BAD_FIELD_ERROR, column_name.length(), column_name.ptr(),
scope_name.length(), scope_name.ptr());
} else if (OB_FAIL(check_ddl_schema_version_from_hint(stmt))) {
LOG_WARN("failed to check ddl schema version", K(ret));
} else {
if (global_hint_.query_timeout_ > 0) {
THIS_WORKER.set_timeout_ts(session_info->get_query_start_time() + global_hint_.query_timeout_);
}
if (global_hint_.has_valid_opt_features_version()) {
query_ctx->optimizer_features_enable_version_ = global_hint_.opt_features_version_;
} else if (OB_FAIL(session_info->get_optimizer_features_enable_version(query_ctx->optimizer_features_enable_version_))) {
LOG_WARN("failed to check ddl schema version", K(ret));
}
}
return ret;
}
int ObQueryHint::check_ddl_schema_version_from_hint(const ObDMLStmt &stmt,
const ObDDLSchemaVersionHint& ddlSchemaVersionHint) const
{
int ret = OB_SUCCESS;
TableItem* item = NULL;
if (OB_FAIL(get_basic_table_without_index_by_hint_table(stmt, ddlSchemaVersionHint.table_, item))) {
LOG_WARN("failed to get table item by hint table", K(ret));
} else if (OB_ISNULL(item)) {
ObSEArray<ObSelectStmt*, 8> child_stmts;
if (OB_FAIL(stmt.get_child_stmts(child_stmts))) {
LOG_WARN("failed to get child stmts", K(ret));
}
for (int64_t index = 0; OB_SUCC(ret) && index < child_stmts.count(); ++index) {
if (OB_FAIL(SMART_CALL(check_ddl_schema_version_from_hint(*child_stmts.at(index),
ddlSchemaVersionHint)))) {
LOG_WARN("failed to check ddl schema version from hint", K(ret));
}
}
} else if (OB_LIKELY(item->ddl_schema_version_ > 0) &&
OB_UNLIKELY(ddlSchemaVersionHint.schema_version_ != item->ddl_schema_version_)) {
ret = OB_DDL_SCHEMA_VERSION_NOT_MATCH;
LOG_USER_ERROR(OB_DDL_SCHEMA_VERSION_NOT_MATCH);
LOG_WARN("failed to check ddl schema version", K(ret), K(item->ddl_schema_version_), K(ddlSchemaVersionHint.schema_version_));
}
return ret;
}
int ObQueryHint::check_ddl_schema_version_from_hint(const ObDMLStmt &stmt) const
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < global_hint_.ob_ddl_schema_versions_.count(); i++) {
if (OB_FAIL(check_ddl_schema_version_from_hint(stmt,
global_hint_.ob_ddl_schema_versions_.at(i)))) {
LOG_WARN("failed to check ddl schema version from hint", K(ret));
}
}
return ret;
}
// init query hint after resolve all stmt.
int ObQueryHint::init_query_hint(ObIAllocator *allocator,
ObSQLSessionInfo *session_info,
ObDMLStmt *stmt)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(allocator) || OB_ISNULL(session_info) || OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(allocator), K(session_info), K(stmt));
} else if (OB_FAIL(session_info->get_collation_type_of_names(OB_TABLE_NAME_CLASS, cs_type_))) {
LOG_WARN("fail to get collation type of name", K(OB_TABLE_NAME_CLASS), K(ret));
} else if (OB_LIKELY(!qb_name_map_.created()) &&
OB_FAIL(qb_name_map_.create(64, ObModIds::OB_SQL_COMPILE))) {
LOG_WARN("failed to create qb name map", K(ret));
} else if (OB_FAIL(reset_duplicate_qb_name())) {
LOG_WARN("failed to reset duplicate qb name", K(ret));
} else if (OB_FAIL(generate_orig_stmt_qb_name(*allocator))) {
LOG_WARN("failed to generate stmt name after resolve", K(ret));
} else if (OB_FAIL(distribute_hint_to_orig_stmt(stmt))) {
LOG_WARN("faild to distribute hint to orig stmt", K(ret));
} else {
LOG_TRACE("finish init query hint", K(*this));
}
return ret;
}
int ObQueryHint::distribute_hint_to_orig_stmt(ObDMLStmt *stmt)
{
int ret = OB_SUCCESS;
ObDMLStmt *root_stmt = stmt;
ObSEArray<ObSelectStmt*, 16> all_child_stmts;
if (OB_ISNULL(stmt)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null stmt", K(ret), K(stmt));
} else if (stmt->is_explain_stmt() &&
OB_FALSE_IT(root_stmt = static_cast<ObExplainStmt*>(stmt)->get_explain_query_stmt())) {
} else if (OB_FAIL(ObTransformUtils::get_all_child_stmts(root_stmt, all_child_stmts))) {
LOG_WARN("failed to get all child stmt", K(ret));
} else {
ObDMLStmt *cur_stmt = NULL;
for (int64_t i = -1; OB_SUCC(ret) && i < all_child_stmts.count(); ++i) {
if (OB_ISNULL(cur_stmt = -1 == i ? root_stmt : all_child_stmts.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null stmt", K(ret), K(cur_stmt));
} else if (OB_FAIL(cur_stmt->set_table_item_qb_name())) {
LOG_WARN("failed to update table item qb name", K(ret));
} else if (OB_FAIL(cur_stmt->get_stmt_hint().init_stmt_hint(*cur_stmt, *this, true))) {
LOG_WARN("failed to init stmt hint", K(ret));
}
}
}
return ret;
}
//after generate a new stmt_id for stmt, need generate new qb_name and add hint from qb_hints
// 1. generate new qb name for stmt
// 2. add hint from qb_hints use new qb name
int ObQueryHint::adjust_qb_name_for_stmt(ObIAllocator &allocator,
ObDMLStmt &stmt,
const ObString &src_qb_name,
const ObIArray<uint32_t> &src_hash_val,
int64_t *sub_num /* default = NULL */)
{
int ret = OB_SUCCESS;
ObString qb_name;
const ObHints *qb_hints = NULL;
stmt.get_stmt_hint().set_query_hint(this);
if (OB_FAIL(generate_qb_name_for_stmt(allocator, stmt, src_qb_name, src_hash_val, qb_name, sub_num))) {
LOG_WARN("failed to generate qb name by str", K(ret));
} else if (has_outline_data() || !stmt.get_stmt_hint().inited()) {
// for outline data, stmts generated by transformer only use hints matched by qb_name
if (OB_FAIL(stmt.get_stmt_hint().init_stmt_hint(stmt, *this, false))) {
LOG_WARN("failed to init stmt hint", K(ret));
}
} else {
ObStmtHint stmt_hint;
if (OB_FAIL(stmt_hint.init_stmt_hint(stmt, *this, false))) {
LOG_WARN("failed to init stmt hint", K(ret));
} else if (OB_FAIL(stmt.get_stmt_hint().merge_stmt_hint(stmt_hint, RIGHT_HINT_DOMINATED))) {
LOG_WARN("failed to merge stmt hint", K(ret));
}
}
// set stmt hint
// if (OB_SUCC(ret) && stmt.is_set_stmt() && OB_FAIL(stmt.get_stmt_hint().set_set_stmt_hint())) {
// LOG_WARN("failed to set set stmt hint", K(ret));
// }
return ret;
}
int ObQueryHint::generate_orig_stmt_qb_name(ObIAllocator &allocator)
{
int ret = OB_SUCCESS;
int64_t sel_start_id = 1;
int64_t set_start_id = 1;
int64_t other_start_id = 1;
char buf[OB_MAX_QB_NAME_LENGTH];
int64_t buf_len = OB_MAX_QB_NAME_LENGTH;
ObString qb_name;
qb_name_map_.reuse();
for (int64_t idx = 0; OB_SUCC(ret) && idx < stmt_id_map_.count(); ++idx) {
QbNames &qb_names = stmt_id_map_.at(idx);
const char *stmt_name = get_dml_stmt_name(qb_names.stmt_type_, qb_names.is_set_stmt_);
int64_t pos = 0;
if (qb_names.is_from_hint_) { /* add qb name from hint */
if (OB_UNLIKELY(1 != qb_names.qb_names_.count() ||
qb_names.qb_names_.at(0).empty())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected qb names", K(ret), K(qb_names.qb_names_));
} else if (OB_FAIL(qb_name_map_.set_refactored(qb_names.qb_names_.at(0), idx))) {
LOG_WARN("failed to set refactored", K(ret));
}
} else if (NULL == stmt_name) {
qb_names.qb_names_.reuse();
} else if (OB_FAIL(BUF_PRINTF("%s", stmt_name))) {
LOG_WARN("failed print buf stmt_name", K(ret));
} else {
int64_t &id_start = stmt::T_SELECT == qb_names.stmt_type_
? (qb_names.is_set_stmt_ ? set_start_id : sel_start_id)
: other_start_id;
int64_t old_pos = pos;
int64_t cnt = 0;
qb_name.reset();
qb_names.qb_names_.reuse();
while(qb_name.empty() && OB_SUCC(ret)) {
pos = old_pos;
if (OB_FAIL(BUF_PRINTF("%ld", id_start))) {
LOG_WARN("failed to print buff", K(ret));
} else if (OB_FAIL(try_add_new_qb_name(allocator, idx, buf, pos, cnt, qb_name))) {
LOG_WARN("failed to try add new qb name", K(ret));
} else {
++id_start;
}
}
if (OB_SUCC(ret) && OB_FAIL(qb_names.qb_names_.push_back(qb_name))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
return ret;
}
// generate new qb name when transform stmt
int ObQueryHint::generate_qb_name_for_stmt(ObIAllocator &allocator,
const ObDMLStmt &stmt,
const ObString &src_qb_name,
const ObIArray<uint32_t> &src_hash_val,
ObString &qb_name,
int64_t *sub_num /* default = NULL */)
{
int ret = OB_SUCCESS;
qb_name.reset();
char buf[OB_MAX_QB_NAME_LENGTH];
int64_t buf_len = OB_MAX_QB_NAME_LENGTH;
int64_t pos = 0;
const char *stmt_name = get_dml_stmt_name(stmt.get_stmt_type(), stmt.is_set_stmt());
const int64_t stmt_id = stmt.get_stmt_id();
uint32_t hash_val = 0;
if (OB_ISNULL(stmt.get_query_ctx())
|| OB_ISNULL(stmt_name)
|| OB_UNLIKELY(0 > stmt_id || stmt_id_map_.count() <= stmt_id)) {
ret = OB_ERR_UNEXPECTED;
LOG_TRACE("unexpected params", K(ret), K(stmt.get_query_ctx()), K(stmt.get_stmt_type()),
K(stmt_id), K(stmt_id_map_.count()));
} else if (OB_FAIL(BUF_PRINTF("%s", stmt_name))) {
LOG_WARN("failed print buf stmt_name", K(ret));
} else if (OB_FAIL(get_qb_name_source_hash_value(src_qb_name, src_hash_val, hash_val))) {
LOG_WARN("failed get qb name source hash value", K(ret));
} else {
int64_t old_pos = pos;
int64_t cnt = 0;
QbNames &qb_names = stmt_id_map_.at(stmt_id);
while(qb_name.empty() && OB_SUCC(ret)) {
pos = old_pos;
if (OB_FAIL(BUF_PRINTF("%08X", hash_val))) {
LOG_WARN("failed to print buff", K(ret));
} else if (NULL != sub_num && OB_FAIL(BUF_PRINTF("_%ld", *sub_num))) {
LOG_WARN("failed to print buff", K(ret));
} else if (OB_FAIL(try_add_new_qb_name(allocator, stmt.get_stmt_id(),
buf, pos, cnt, qb_name))) {
LOG_WARN("failed to try add new qb name", K(ret));
} else if (NULL != sub_num) {
++*sub_num;
} else {
++hash_val;
}
}
if (OB_SUCC(ret)) {
if (qb_names.qb_names_.empty()) {
qb_names.reset();
qb_names.stmt_type_ = stmt.get_stmt_type();
qb_names.is_set_stmt_ = stmt.is_set_stmt();
qb_names.parent_name_ = src_qb_name;
}
if (OB_FAIL(qb_names.qb_names_.push_back(qb_name))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
return ret;
}
int ObQueryHint::try_add_new_qb_name(ObIAllocator &allocator,
int64_t stmt_id,
const char *ptr,
int64_t length,
int64_t &cnt,
ObString &qb_name)
{
int ret = OB_SUCCESS;
qb_name.reset();
cnt = cnt < 0 ? 0 : cnt;
int64_t tmp_stmt_id = OB_INVALID_STMT_ID;
ObString tmp_name;
tmp_name.assign_ptr(ptr, length);
if (OB_FAIL(qb_name_map_.get_refactored(tmp_name, tmp_stmt_id))
&& OB_UNLIKELY(OB_HASH_NOT_EXIST != ret)) {
LOG_WARN("failed to get refactored", K(ret));
} else if (OB_LIKELY(OB_HASH_NOT_EXIST == ret)) {
if (OB_FAIL(ob_write_string(allocator, tmp_name, qb_name))) {
LOG_WARN("Write string error", K(ret));
} else if (OB_FAIL(qb_name_map_.set_refactored(qb_name, stmt_id))) {
LOG_WARN("failed to set refactored", K(ret));
}
} else {
++cnt;
if (cnt%50 == 0) {
LOG_TRACE("try generate qb_name by str too hard", K(cnt));
}
if (OB_UNLIKELY(cnt > 1000)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to generate a qb_name by str", K(ret), K(cnt));
}
}
return ret;
}
// reset duplicate qb name from qb_name hint
int ObQueryHint::reset_duplicate_qb_name()
{
int ret = OB_SUCCESS;
int64_t idx = 0;
qb_name_map_.reuse();
for (int64_t i = 0; OB_SUCC(ret) && i < stmt_id_map_.count(); ++i) {
QbNames &qb_names = stmt_id_map_.at(i);
if (!qb_names.is_from_hint_) {
qb_names.qb_names_.reuse();
} else if (qb_names.qb_names_.empty()) {
/* do nothing */
} else if (OB_UNLIKELY(1 != qb_names.qb_names_.count() ||
qb_names.qb_names_.at(0).empty())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected qb names", K(ret), K(qb_names.qb_names_));
} else if (OB_FAIL(qb_name_map_.get_refactored(qb_names.qb_names_.at(0), idx))) {
if (OB_UNLIKELY(OB_HASH_NOT_EXIST != ret)) {
LOG_WARN("get stmt id from hash map failed", K(ret));
} else if (OB_FAIL(qb_name_map_.set_refactored(qb_names.qb_names_.at(0), i))) {
LOG_WARN("failed to add name map", K(ret));
}
} else if (OB_UNLIKELY(idx < 0 || idx >= i)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected idx.", K(ret), K(idx), K(i));
} else {
qb_names.qb_names_.reuse();
qb_names.is_from_hint_ = false;
stmt_id_map_.at(idx).qb_names_.reuse();
stmt_id_map_.at(idx).is_from_hint_ = false;
}
}
qb_name_map_.reuse();
return ret;
}
const char *ObQueryHint::get_dml_stmt_name(stmt::StmtType stmt_type, bool is_set_stmt) const
{
switch (stmt_type) {
case stmt::T_SELECT:
if (is_set_stmt) {
return "SET$";
} else {
return "SEL$";
}
case stmt::T_INSERT_ALL: return "INS_ALL$";
case stmt::T_INSERT: return "INS$";
case stmt::T_REPLACE: return "REP$";
case stmt::T_UPDATE: return "UPD$";
case stmt::T_DELETE: return "DEL$";
case stmt::T_MERGE: return "MRG$";
default: return NULL;
}
}
int ObQueryHint::get_qb_name_counts(const int64_t stmt_count, ObIArray<int64_t> &qb_name_counts) const
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(stmt_id_map_.count() != stmt_count)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected stmt id map count", K(stmt_id_map_.count()), K(stmt_count));
} else if (OB_FAIL(qb_name_counts.prepare_allocate(stmt_count))) {
LOG_WARN("fail to prepare allocate", K(ret), K(stmt_count));
} else {
for (int i = 0; OB_SUCC(ret) && i < stmt_count; ++i) {
if (OB_UNLIKELY(stmt_id_map_.at(i).qb_names_.empty() &&
NULL != get_dml_stmt_name(stmt_id_map_.at(i).stmt_type_, false))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected qb names for stmt id", K(ret), K(i), K(stmt_id_map_.at(i).qb_names_));
} else {
qb_name_counts.at(i) = stmt_id_map_.at(i).qb_names_.count();
}
}
}
return ret;
}
int ObQueryHint::recover_qb_names(const ObIArray<int64_t> &qb_name_counts, int64_t &stmt_count)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(stmt_id_map_.count() != stmt_count)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected stmt id map count", K(stmt_id_map_.count()), K(stmt_count));
} else {
int64_t pre_qb_name_count = 0;
for (int i = stmt_id_map_.count() - 1; OB_SUCC(ret) && i >= 0; --i) {
pre_qb_name_count = i < qb_name_counts.count() ? qb_name_counts.at(i) : 0;
ObIArray<ObString> &qb_names = stmt_id_map_.at(i).qb_names_;
for (int j = qb_names.count() - 1; OB_SUCC(ret) && j >= pre_qb_name_count; --j) {
if (OB_FAIL(qb_name_map_.erase_refactored(qb_names.at(j)))) {
LOG_WARN("unexpected qb names for stmt id", K(ret), K(i), K(qb_names.at(j)));
} else {
qb_names.pop_back();
}
}
if (OB_SUCC(ret) && i >= qb_name_counts.count()) {
stmt_id_map_.pop_back();
--stmt_count;
}
}
}
return ret;
}
int ObQueryHint::print_qb_name_hints(PlanText &plan_text) const
{
int ret = OB_SUCCESS;
char *buf = plan_text.buf_;
int64_t &buf_len = plan_text.buf_len_;
int64_t &pos = plan_text.pos_;
for (int64_t i = 0; OB_SUCC(ret) && i < stmt_id_map_.count(); ++i) {
if (stmt_id_map_.at(i).is_from_hint_) {
const ObIArray<ObString> &qb_names = stmt_id_map_.at(i).qb_names_;
if (OB_UNLIKELY(qb_names.empty() || qb_names.at(0).empty())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected qb name hint", K(ret), K(i), K(stmt_id_map_.at(i)));
} else if (OB_FAIL(BUF_PRINTF("%sQB_NAME(%.*s)", get_outline_indent(plan_text.is_oneline_),
qb_names.at(0).length(), qb_names.at(0).ptr()))) {
LOG_WARN("failed to print qb_name hint", K(ret));
}
}
}
return ret;
}
// Used for stmt printer
// If outline_stmt_id_ is invalid stmt id and has_outline_data(), do not print hint.
// This may happened for outline data from SPM.
int ObQueryHint::print_stmt_hint(PlanText &plan_text, const ObDMLStmt &stmt,
const bool is_first_stmt_for_hint) const
{
int ret = OB_SUCCESS;
const int64_t stmt_id = stmt.get_stmt_id();
if (OB_FAIL(print_qb_name_hint(plan_text, stmt_id))) {
LOG_WARN("failed to print qb_name hint", K(ret));
} else if (OB_INVALID_STMT_ID != stmt_id && stmt_id == outline_stmt_id_) {
// Outline data resolved from this stmt, print outline data here.
if (OB_FAIL(print_outline_data(plan_text))) {
LOG_WARN("failed to print outline data", K(ret));
}
} else if (!has_outline_data()) {
// Not outline data, print current stmt hint here.
// If stmt is the first stmt can add hint, print global hint and hint with qb name.
// For query "select_1 union all select_2", root stmt is "union all" and the first stmt to print hint is select_1
if (is_first_stmt_for_hint &&
OB_FAIL(get_global_hint().print_global_hint(plan_text))) {
LOG_WARN("failed to print global hint", K(ret));
} else if (OB_FAIL(stmt.get_stmt_hint().print_stmt_hint(plan_text))) {
LOG_WARN("failed to print stmt hint", K(ret));
} else if (is_first_stmt_for_hint) {
int tmp = OB_SUCCESS;
int64_t tmp_stmt_id = OB_INVALID_STMT_ID;
for (int64_t i = 0; OB_SUCC(ret) && i < qb_hints_.count(); ++i) {
if (OB_FAIL(qb_name_map_.get_refactored(qb_hints_.at(i).qb_name_, tmp_stmt_id))) {
if (OB_UNLIKELY(OB_HASH_NOT_EXIST != ret)) {
LOG_WARN("failed to check hash map exists", K(ret));
} else if (OB_FAIL(qb_hints_.at(i).print_hints(plan_text))) {
LOG_WARN("failed to print hint", K(ret));
}
}
}
}
}/* */
return ret;
}
// used for stmt printer
int ObQueryHint::print_outline_data(PlanText &plan_text) const
{
int ret = OB_SUCCESS;
char *buf = plan_text.buf_;
int64_t &buf_len = plan_text.buf_len_;
int64_t &pos = plan_text.pos_;
bool is_oneline = plan_text.is_oneline_;
if (OB_UNLIKELY(1 < stmt_id_hints_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected stmt id hints for outline data", K(ret), K(stmt_id_hints_));
} else if (OB_FAIL(BUF_PRINTF("%sBEGIN_OUTLINE_DATA", ObQueryHint::get_outline_indent(is_oneline)))) {
} else if (1 == stmt_id_hints_.count() &&
OB_FAIL(stmt_id_hints_.at(0).print_hints(plan_text, true))) {
LOG_WARN("failed to print hint", K(ret));
} else {
const ObHint *hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < qb_hints_.count(); ++i) {
if (OB_FAIL(qb_hints_.at(i).print_hints(plan_text, true))) {
LOG_WARN("failed to print hint", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < trans_list_.count(); ++i) {
if (OB_ISNULL(hint = trans_list_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(i), K(trans_list_));
} else if (OB_FAIL(hint->print_hint(plan_text))) {
LOG_WARN("failed to print hint", K(ret));
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(get_global_hint().print_global_hint(plan_text))) {
LOG_WARN("failed to print global hint", K(ret));
} else if (OB_FAIL(BUF_PRINTF("%sEND_OUTLINE_DATA", ObQueryHint::get_outline_indent(is_oneline)))) {
LOG_WARN("fail to print buf", K(ret));
}
}
return ret;
}
int ObQueryHint::print_qb_name_hint(PlanText &plan_text, int64_t stmt_id) const
{
int ret = OB_SUCCESS;
if (OB_INVALID_STMT_ID == stmt_id) {
/* do nothing, this stmt is create for print stmt for mv */
} else if (OB_UNLIKELY(stmt_id < 0 || stmt_id >= stmt_id_map_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected stmt id", K(ret), K(stmt_id), K(stmt_id_map_.count()));
} else if (stmt_id_map_.at(stmt_id).is_from_hint_) {
const ObIArray<ObString> &qb_names = stmt_id_map_.at(stmt_id).qb_names_;
char *buf = plan_text.buf_;
int64_t &buf_len = plan_text.buf_len_;
int64_t &pos = plan_text.pos_;
if (OB_UNLIKELY(qb_names.empty() || qb_names.at(0).empty())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected qb name hint", K(ret), K(stmt_id), K(stmt_id_map_.at(stmt_id)));
} else if (OB_FAIL(BUF_PRINTF("%sQB_NAME(%.*s)", get_outline_indent(plan_text.is_oneline_),
qb_names.at(0).length(), qb_names.at(0).ptr()))) {
LOG_WARN("failed to print qb_name hint", K(ret));
}
}
return ret;
}
int ObQueryHint::print_transform_hints(PlanText &plan_text) const
{
int ret = OB_SUCCESS;
const ObIArray<const ObHint*> *hints = NULL;
if (plan_text.is_used_hint_) {
hints = &used_trans_hints_;
} else {
hints = &outline_trans_hints_;
}
for (int64_t i = 0; OB_SUCC(ret) && i < hints->count(); ++i) {
if (OB_ISNULL(hints->at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(hints->at(i)));
} else if (OB_FAIL(hints->at(i)->print_hint(plan_text))) {
LOG_WARN("failed to print transform hint", K(ret), K(*hints->at(i)));
}
}
return ret;
}
int ObQueryHint::get_relids_from_hint_tables(const ObDMLStmt &stmt,
const ObIArray<ObTableInHint> &tables,
ObRelIds &rel_ids) const
{
int ret = OB_SUCCESS;
rel_ids.reuse();
bool is_valid = true;
int32_t index = OB_INVALID_INDEX;
for (int64_t i = 0; is_valid && OB_SUCC(ret) && i < tables.count(); ++i) {
if (OB_FAIL(get_table_bit_index_by_hint_table(stmt, tables.at(i), index))) {
LOG_WARN("failed to get table bit index by hint table.", K(ret));
} else if (OB_INVALID_INDEX == index) {
is_valid = false;
} else if (OB_FAIL(rel_ids.add_member(index))) {
LOG_WARN("failed to add members", K(ret));
}
}
if (OB_SUCC(ret) && !is_valid) {
rel_ids.reuse();
}
return ret;
}
int ObQueryHint::get_table_bit_index_by_hint_table(const ObDMLStmt &stmt,
const ObTableInHint &table,
int32_t &idx) const
{
int ret = OB_SUCCESS;
idx = OB_INVALID_INDEX;
TableItem *table_item = NULL;
if (OB_FAIL(get_table_item_by_hint_table(stmt, table, table_item))) {
LOG_WARN("failed to get table bit index by hint table.", K(ret));
} else if (NULL == table_item) {
/* do nothing */
} else {
idx = stmt.get_table_bit_index(table_item->table_id_);
}
return ret;
}
int ObQueryHint::get_table_item_by_hint_table(const ObDMLStmt &stmt,
const ObTableInHint &table,
TableItem *&table_item) const
{
int ret = OB_SUCCESS;
table_item = NULL;
bool implicit_match_allowed = table.qb_name_.empty();
const ObIArray<TableItem*> &table_items = stmt.get_table_items();
TableItem *cur_table_item = NULL;
TableItem *explicit_matched = NULL;
TableItem *implicit_matched = NULL;
for (int64_t i = 0; OB_SUCC(ret) && NULL == explicit_matched && i < table_items.count(); ++i) {
if (OB_ISNULL(cur_table_item = table_items.at(i)) || OB_UNLIKELY(cur_table_item->qb_name_.empty())) {
ret = OB_ERR_UNEXPECTED; // qb_name_ should not be empty
LOG_WARN("unexpected table item.", K(ret), K(cur_table_item));
} else if (!table.is_match_table_item(cs_type_, *cur_table_item)) {
/* do nothing */
} else if (0 == cur_table_item->qb_name_.case_compare(table.qb_name_)) {
explicit_matched = cur_table_item;
} else if (!implicit_match_allowed) {
/* do nothing */
} else if (NULL == implicit_matched) {
implicit_matched = cur_table_item;
} else {
implicit_match_allowed = false;
implicit_matched = NULL;
}
}
if (OB_SUCC(ret)) {
table_item = NULL != explicit_matched ? explicit_matched : implicit_matched;
if (NULL == table_item) {
LOG_TRACE("no table item matched hint table", K(table), K(table_items));
}
}
return ret;
}
int ObQueryHint::get_basic_table_without_index_by_hint_table(const ObDMLStmt &stmt,
const ObTableInHint &table,
TableItem *&table_item) const
{
int ret = OB_SUCCESS;
table_item = NULL;
const ObIArray<TableItem*> &table_items = stmt.get_table_items();
int64_t num = table_items.count();
TableItem *item = NULL;
table_item = NULL;
for (int64_t i = 0; OB_SUCC(ret) && NULL == table_item && i < num; ++i) {
if (OB_ISNULL(item = table_items.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected table item.", K(ret), K(item));
} else if (!item->is_basic_table()) {
/* do nothing */
} else if (OB_LIKELY(item->ddl_table_id_ != OB_INVALID_ID) && OB_UNLIKELY(item->ddl_table_id_ != item->ref_id_)) {
// do nothing
} else if (!table.is_match_physical_table_item(cs_type_, *item)) {
/* do nothing */
} else {
table_item = item;
}
}
return ret;
}
int ObQueryHint::get_qb_name(int64_t stmt_id, ObString &qb_name) const
{
int ret = OB_SUCCESS;
qb_name.reset();
if (OB_UNLIKELY(stmt_id < 0 || stmt_id >= stmt_id_map_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected stmt id", K(ret), K(stmt_id), K(stmt_id_map_.count()), K(stmt_id_map_));
} else {
const ObIArray<ObString> &qb_names = stmt_id_map_.at(stmt_id).qb_names_;
if (OB_UNLIKELY(qb_names.empty() || qb_names.at(qb_names.count() - 1).empty())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected qb names", K(ret), K(stmt_id), K(stmt_id_map_.at(stmt_id)));
} else {
qb_name = qb_names.at(qb_names.count() - 1);
}
}
return ret;
}
int ObQueryHint::fill_tables(const TableItem &table, ObIArray<ObTableInHint> &hint_tables) const
{
int ret = OB_SUCCESS;
hint_tables.reuse();
ObSEArray<const TableItem*, 4> tables;
if (OB_FAIL(tables.push_back(&table))) {
LOG_WARN("failed to push back", K(ret));
} else {
const TableItem *cur_table = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < tables.count(); ++i) {
if (OB_ISNULL(cur_table = tables.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(i), K(tables));
} else if (cur_table->is_joined_table()) {
const JoinedTable *join_table = static_cast<const JoinedTable*>(cur_table);
if (OB_FAIL(tables.push_back(join_table->left_table_))
|| OB_FAIL(tables.push_back(join_table->right_table_))) {
LOG_WARN("failed to push back", K(ret));
}
} else if (OB_FAIL(hint_tables.push_back(ObTableInHint(cur_table->qb_name_,
cur_table->database_name_,
cur_table->get_object_name())))) {
LOG_WARN("failed to push back", K(ret));
}
}
}
return ret;
}
bool ObQueryHint::is_valid_outline_transform(int64_t trans_list_loc, const ObHint *cur_hint) const
{
bool bret = false;
const ObHint *trans_hint = NULL;
if (NULL == cur_hint ||
NULL == (trans_hint = get_outline_trans_hint(trans_list_loc)) ||
trans_hint->get_orig_hint() != cur_hint->get_orig_hint()) {
/* do nothing */
} else {
bret = true;
}
return bret;
}
void QbNames::reset()
{
stmt_type_ = stmt::StmtType::T_NONE;
is_set_stmt_ = false;
is_from_hint_ = false;
parent_name_.reset();
qb_names_.reset();
}
int QbNames::print_qb_names(PlanText &plan_text) const
{
int ret = OB_SUCCESS;
char *buf = plan_text.buf_;
int64_t &buf_len = plan_text.buf_len_;
int64_t &pos = plan_text.pos_;
int64_t idx = is_from_hint_ ? 1 : 0;
if (OB_UNLIKELY(qb_names_.empty())) {
ObString stmt_type = ObResolverUtils::get_stmt_type_string(stmt_type_);
if (OB_FAIL(BUF_PRINTF("stmt_type:%.*s ", stmt_type.length(), stmt_type.ptr()))) {
LOG_WARN("failed to print parent stmt type", K(ret));
}
} else if (is_from_hint_) {
if (OB_UNLIKELY(qb_names_.empty() || qb_names_.at(0).empty())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected qb name hint", K(ret), K(*this));
} else if (OB_FAIL(BUF_PRINTF("qb_name(%.*s) ", qb_names_.at(0).length(), qb_names_.at(0).ptr()))) {
LOG_WARN("failed to print qb_name from hint", K(ret));
}
} else if (!parent_name_.empty()) {
if (OB_FAIL(BUF_PRINTF("parent:%.*s ", parent_name_.length(), parent_name_.ptr()))) {
LOG_WARN("failed to print parent qb_name", K(ret));
}
}
if (OB_SUCC(ret) && qb_names_.count() > idx) {
if ((is_from_hint_ || !parent_name_.empty()) && OB_FAIL(BUF_PRINTF(" > "))) {
LOG_WARN("failed to print parent qb_name", K(ret));
}
for (int64_t i = idx; OB_SUCC(ret) && i < qb_names_.count(); ++i) {
if (OB_FAIL(BUF_PRINTF("%.*s", qb_names_.at(i).length(), qb_names_.at(i).ptr()))) {
LOG_WARN("failed to print qb_name hint", K(ret));
} else if ((i < qb_names_.count() - 1) && OB_FAIL(BUF_PRINTF(" > "))) {
LOG_WARN("failed to print parent qb_name", K(ret));
}
}
}
return ret;
}
int ObHints::assign(const ObHints &other)
{
int ret = OB_SUCCESS;
stmt_id_ = other.stmt_id_;
qb_name_ = other.qb_name_;
if (OB_FAIL(hints_.assign(other.hints_))) {
LOG_WARN("failed to assign hints", K(ret));
}
return ret;
}
int ObHints::print_hints(PlanText &plan_text, bool ignore_trans_hint /* default false */ ) const
{
int ret = OB_SUCCESS;
const ObHint *hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < hints_.count(); ++i) {
if (OB_ISNULL(hint = hints_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(hint));
} else if (ignore_trans_hint && hint->is_transform_hint()) {
/* do nothing */
} else if (OB_FAIL(hint->print_hint(plan_text))) {
LOG_WARN("failed to print transform hint", K(ret), K(*hint));
}
}
return ret;
}
void ObStmtHint::reset()
{
query_hint_ = NULL;
normal_hints_.reuse();
other_opt_hints_.reuse();
}
int ObStmtHint::assign(const ObStmtHint &other)
{
int ret = OB_SUCCESS;
query_hint_ = other.query_hint_;
if (OB_FAIL(normal_hints_.assign(other.normal_hints_))) {
LOG_WARN("failed to assign normal hints", K(ret));
} else if (OB_FAIL(other_opt_hints_.assign(other.other_opt_hints_))) {
LOG_WARN("failed to assign other opt hints", K(ret));
}
return ret;
}
DEF_TO_STRING(ObStmtHint)
{
int64_t pos = 0;
J_OBJ_START();
const ObHint *hint = NULL;
const int64_t N = get_hint_count();
for (int64_t i = 0; i < N; ++i) {
hint = get_hint_by_idx(i);
if (NULL != hint) {
J_KV(K(hint));
J_COMMA();
}
}
J_OBJ_END();
return pos;
}
int ObStmtHint::print_stmt_hint(PlanText &plan_text) const
{
int ret = OB_SUCCESS;
const ObHint *hint = NULL;
const int64_t N = get_hint_count();
const bool ignore_parallel = EXPLAIN_DBLINK_STMT == plan_text.type_;
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
if (OB_ISNULL(hint = get_hint_by_idx(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(hint));
} else if (ignore_parallel && hint->is_table_parallel_hint()) {
// do nothing
} else if (OB_FAIL(hint->print_hint(plan_text))) {
LOG_WARN("failed to print hint", K(ret));
}
}
return ret;
}
int ObStmtHint::init_stmt_hint(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
bool use_stmt_id_hints)
{
int ret = OB_SUCCESS;
reset();
set_query_hint(&query_hint);
ObString qb_name;
const ObHints *qb_hints = NULL;
ObSEArray<ObHint*, 16> all_hints;
if (OB_FAIL(stmt.get_qb_name(qb_name))) {
LOG_WARN("failed to get qb name", K(ret));
} else if (NULL != (qb_hints = query_hint.get_qb_hints(qb_name))
&& OB_FAIL(all_hints.assign(qb_hints->hints_))) {
LOG_WARN("failed to assign hints", K(ret));
} else if (use_stmt_id_hints
&& NULL != (qb_hints = query_hint.get_stmt_id_hints(stmt.get_stmt_id()))
&& OB_FAIL(append(all_hints, qb_hints->hints_))) {
LOG_WARN("failed to append hints", K(ret));
} else {
ObSEArray<ObItemType, 4> conflict_hints;
for (int64_t i = 0; OB_SUCC(ret) && i < all_hints.count(); ++i) {
if (OB_ISNULL(all_hints.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(i), K(all_hints));
} else if (OB_FAIL(merge_hint(*all_hints.at(i), HINT_DOMINATED_EQUAL, conflict_hints))) {
LOG_WARN("failed to merge hint", K(ret));
}
}
LOG_TRACE("finish init stmt hint", K(stmt.get_stmt_id()), K(qb_name), K(*this));
}
return ret;
}
int ObStmtHint::merge_stmt_hint(const ObStmtHint &other,
ObHintMergePolicy policy /* default HINT_DOMINATED_EQUAL */)
{
int ret = OB_SUCCESS;
ObSEArray<ObItemType, 4> conflict_hints;
for (int64_t i = 0; OB_SUCC(ret) && i < other.normal_hints_.count(); ++i) {
if (OB_ISNULL(other.normal_hints_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(other.normal_hints_));
} else if (OB_FAIL(merge_normal_hint(*other.normal_hints_.at(i), policy, conflict_hints))) {
LOG_WARN("failed to merge normal hint", K(ret));
}
}
if (OB_SUCC(ret) && OB_FAIL(append_array_no_dup(other_opt_hints_, other.other_opt_hints_))) {
LOG_WARN("failed to append other opt hint", K(ret));
}
return ret;
}
const ObHint *ObStmtHint::get_normal_hint(ObItemType hint_type, int64_t *idx /* default NULL */) const
{
const ObHint *hint = NULL;
if (NULL != idx) { *idx = -1; }
for (int64_t i = 0; NULL == hint && i < normal_hints_.count(); ++i) {
if (OB_ISNULL(normal_hints_.at(i))) {
/* do nothing */
} else if (normal_hints_.at(i)->get_hint_type() == hint_type) {
hint = normal_hints_.at(i);
if (NULL != idx) { *idx = i; }
}
}
return hint;
}
ObHint *ObStmtHint::get_normal_hint(ObItemType hint_type, int64_t *idx /* default NULL */)
{
ObHint *hint = NULL;
if (NULL != idx) { *idx = -1; }
for (int64_t i = 0; NULL == hint && i < normal_hints_.count(); ++i) {
if (OB_ISNULL(normal_hints_.at(i))) {
/* do nothing */
} else if (normal_hints_.at(i)->get_hint_type() == hint_type) {
hint = normal_hints_.at(i);
if (NULL != idx) { *idx = i; }
}
}
return hint;
}
const ObHint *ObStmtHint::get_hint_by_idx(int64_t idx) const
{
const ObHint *hint = NULL;
int64_t cur_idx = idx;
if (cur_idx < normal_hints_.count()) {
hint = normal_hints_.at(cur_idx);
} else if ((cur_idx -= normal_hints_.count()) < other_opt_hints_.count()) {
hint = other_opt_hints_.at(cur_idx);
} else {
hint = NULL;
}
return hint;
}
int ObStmtHint::set_hint(int64_t idx, ObHint *hint)
{
int ret = OB_SUCCESS;
int64_t cur_idx = idx;
if (OB_UNLIKELY(idx < 0 || idx >= get_hint_count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected idx", K(ret), K(idx), K(get_hint_count()));
} else if (cur_idx < normal_hints_.count()) {
normal_hints_.at(cur_idx) = hint;
} else if ((cur_idx -= normal_hints_.count()) < other_opt_hints_.count()) {
other_opt_hints_.at(cur_idx) = hint;
}
return ret;
}
int ObStmtHint::set_set_stmt_hint()
{
int ret = OB_SUCCESS;
static const int64_t VALID_HINT_SIZE = 6;
ObItemType valid_hint[VALID_HINT_SIZE] = { T_NO_REWRITE,
T_SIMPLIFY_SET,
T_PQ_SET,
T_USE_HASH_SET,
T_USE_HASH_DISTINCT,
T_DISTINCT_PUSHDOWN};
const ObQueryHint *query_hint = query_hint_;
ObSEArray<ObHint*, 4> hints;
for (int64_t i = 0; OB_SUCC(ret) && i < normal_hints_.count(); ++i) {
if (OB_ISNULL(normal_hints_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(i), K(normal_hints_.at(i)));
} else if (!has_exist_in_array(valid_hint, VALID_HINT_SIZE, normal_hints_.at(i)->get_hint_type())) {
/* do nothing */
} else if (OB_FAIL(hints.push_back(normal_hints_.at(i)))) {
LOG_WARN("failed to push back", K(ret));
}
}
if (OB_SUCC(ret)) {
reset();
query_hint_ = query_hint;
if (OB_FAIL(normal_hints_.assign(hints))) {
LOG_WARN("failed to assign hints", K(ret));
}
}
return ret;
}
int ObStmtHint::set_simple_view_hint(const ObStmtHint *other /* default NULL */ )
{
int ret = OB_SUCCESS;
static const int64_t RESET_HINT_SIZE = 3;
ObItemType reset_hint[RESET_HINT_SIZE] = { T_MERGE_HINT, T_USE_HASH_AGGREGATE, T_PLACE_GROUP_BY };
if (NULL != other && OB_FAIL(assign(*other))) {
LOG_WARN("failed to assign stmt hint", K(ret));
} else if (OB_FAIL(remove_normal_hints(reset_hint, RESET_HINT_SIZE))) {
LOG_WARN("failed to remove hints", K(ret));
}
return ret;
}
int ObStmtHint::remove_normal_hints(const ObItemType *hint_array, const int64_t num)
{
int ret = OB_SUCCESS;
ObSEArray<ObHint*, 4> hints;
for (int64_t i = 0; OB_SUCC(ret) && i < normal_hints_.count(); ++i) {
if (OB_ISNULL(normal_hints_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(i), K(normal_hints_.at(i)));
} else if (has_exist_in_array(hint_array, num, normal_hints_.at(i)->get_hint_type())) {
/* do nothing */
} else if (OB_FAIL(hints.push_back(normal_hints_.at(i)))) {
LOG_WARN("failed to push back", K(ret));
}
}
if (OB_SUCC(ret) && hints.count() != normal_hints_.count()
&& OB_FAIL(normal_hints_.assign(hints))) {
LOG_WARN("failed to assign hints", K(ret));
}
return ret;
}
int ObStmtHint::replace_name_for_single_table_view(ObIAllocator *allocator,
const ObDMLStmt &stmt,
const TableItem &view_table)
{
int ret = OB_SUCCESS;
const TableItem *target_table = NULL;
const ObDMLStmt *child_stmt = NULL;
if (OB_ISNULL(query_hint_)
|| OB_ISNULL(stmt.get_table_item_by_id(view_table.table_id_))
|| OB_UNLIKELY(!view_table.is_generated_table())
|| OB_ISNULL(child_stmt = view_table.ref_query_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected params", K(ret), K(query_hint_), K(target_table), K(child_stmt));
} else if (child_stmt->get_from_item_size() != 1
|| child_stmt->get_from_item(0).is_joined_) {
/* do nothing */
} else if (OB_ISNULL(target_table = child_stmt->get_table_item(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(target_table));
} else if (0 == ObCharset::strcmp(query_hint_->cs_type_, view_table.get_object_name(),
target_table->get_object_name())) {
/* need not replace name */
} else {
LOG_DEBUG("replace name for single table view in hint", K(view_table), K(*target_table));
const int64_t N = get_hint_count();
ObHint *hint = NULL;
ObHint *new_hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
if (OB_ISNULL(hint = const_cast<ObHint*>(get_hint_by_idx(i)))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(i));
} else if (OB_FAIL(hint->create_push_down_hint(allocator, query_hint_->cs_type_,
view_table, *target_table, new_hint))) {
LOG_WARN("failed to create push down hint", K(ret), K(i), K(*hint));
} else if (OB_FAIL(set_hint(i, new_hint))) {
LOG_WARN("failed to set hint", K(ret), K(i), K(new_hint));
}
}
}
return ret;
}
// deal hint conflict and add hint
int ObStmtHint::merge_hint(ObHint &hint,
ObHintMergePolicy policy,
ObIArray<ObItemType> &conflict_hints)
{
int ret = OB_SUCCESS;
if (hint.is_access_path_hint()
|| hint.is_join_hint()
|| hint.is_join_filter_hint()
|| hint.is_table_parallel_hint()
|| hint.is_table_dynamic_sampling_hint()
|| hint.is_pq_subquery_hint()) {
if (OB_FAIL(add_var_to_array_no_dup(other_opt_hints_, &hint))) {
LOG_WARN("failed to add var to array", K(ret));
}
} else if (OB_FAIL(merge_normal_hint(hint, policy, conflict_hints))) {
LOG_WARN("failed to merge normal hint", K(ret));
}
return ret;
}
int ObStmtHint::merge_normal_hint(ObHint &hint,
ObHintMergePolicy policy,
ObIArray<ObItemType> &conflict_hints)
{
int ret = OB_SUCCESS;
const ObHint *final_hint = NULL;
int64_t idx = -1;
const ObHint *cur_hint = get_normal_hint(hint.get_hint_type(), &idx);
if (OB_FAIL(hint.merge_hint(cur_hint, &hint, policy, conflict_hints, final_hint))) {
LOG_WARN("failed to merge hint", K(ret));
} else if (cur_hint == final_hint) {
/* do nothing */
} else if (NULL != cur_hint && NULL == final_hint) {
if (OB_FAIL(normal_hints_.remove(idx))) {
LOG_WARN("failed to remove hint", K(ret));
}
} else if (NULL == cur_hint && NULL != final_hint) {
if (OB_FAIL(normal_hints_.push_back(const_cast<ObHint*>(final_hint)))) {
LOG_WARN("failed to push back", K(ret));
}
} else if (NULL != cur_hint && NULL != final_hint) {
if (OB_FAIL(set_hint(idx, const_cast<ObHint*>(final_hint)))) {
LOG_WARN("failed to set single hint", K(ret));
}
}
return ret;
}
int ObStmtHint::reset_explicit_trans_hint(ObItemType hint_type)
{
int ret = OB_SUCCESS;
const ObHint *cur_hint = get_normal_hint(hint_type);
if (NULL == cur_hint) {
/* do nothing */
} else if (OB_UNLIKELY(!cur_hint->is_transform_hint())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected hint type", K(ret), K(*cur_hint));
} else if (!static_cast<const ObTransHint*>(cur_hint)->is_explicit()) {
/* do nothing */
} else if (OB_FAIL(remove_normal_hints(&hint_type, 1))) {
LOG_WARN("failed to remove hints", K(ret));
}
return ret;
}
bool ObStmtHint::has_enable_hint(ObItemType hint_type) const
{
const ObHint *cur_hint = get_normal_hint(hint_type);
return NULL != cur_hint && cur_hint->is_enable_hint();
}
bool ObStmtHint::has_disable_hint(ObItemType hint_type) const
{
const ObHint *cur_hint = get_normal_hint(hint_type);
return NULL != cur_hint && cur_hint->is_disable_hint();
}
void ObLogPlanHint::reset()
{
is_outline_data_ = false;
#ifdef OB_BUILD_SPM
is_spm_evolution_ = false;
#endif
join_order_.reset();
table_hints_.reuse();
join_hints_.reuse();
normal_hints_.reuse();
}
#ifndef OB_BUILD_SPM
int ObLogPlanHint::init_log_plan_hint(ObSqlSchemaGuard &schema_guard,
const ObDMLStmt &stmt,
const ObQueryHint &query_hint)
#else
int ObLogPlanHint::init_log_plan_hint(ObSqlSchemaGuard &schema_guard,
const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const bool is_spm_evolution)
#endif
{
int ret = OB_SUCCESS;
reset();
is_outline_data_ = query_hint.has_outline_data();
#ifdef OB_BUILD_SPM
is_spm_evolution_ = is_spm_evolution;
#endif
const ObStmtHint &stmt_hint = stmt.get_stmt_hint();
if (OB_FAIL(join_order_.init_leading_info(stmt, query_hint, stmt_hint.get_normal_hint(T_LEADING)))) {
LOG_WARN("failed to get leading hint info", K(ret));
} else if (OB_FAIL(init_normal_hints(stmt_hint.normal_hints_))) {
LOG_WARN("failed to init normal hints", K(ret));
} else if (OB_FAIL(init_other_opt_hints(schema_guard, stmt, query_hint,
stmt_hint.other_opt_hints_))) {
LOG_WARN("failed to init other opt hints", K(ret));
} else {
LOG_TRACE("finish init log plan hint", K(stmt.get_stmt_id()), K(*this), K(stmt_hint.normal_hints_), K(stmt_hint.other_opt_hints_));
}
return ret;
}
int ObLogPlanHint::init_normal_hints(const ObIArray<ObHint*> &normal_hints)
{
int ret = OB_SUCCESS;
const ObHint *hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < normal_hints.count(); ++i) {
if (OB_ISNULL(hint = normal_hints.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(i), K(normal_hints));
} else if (hint->is_transform_hint() || hint->is_join_order_hint()) {
/* do nothing */
} else if (OB_FAIL(normal_hints_.push_back(hint))) {
LOG_WARN("failed to push back", K(ret));
}
}
return ret;
}
int ObLogPlanHint::init_other_opt_hints(ObSqlSchemaGuard &schema_guard,
const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObIArray<ObHint*> &hints)
{
int ret = OB_SUCCESS;
const ObHint *hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < hints.count(); ++i) {
if (OB_ISNULL(hint = hints.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(i));
} else if (hint->is_access_path_hint()) {
if (OB_FAIL(add_index_hint(stmt, query_hint, *static_cast<const ObIndexHint*>(hint)))) {
LOG_WARN("failed to add index hint", K(ret));
}
} else if (hint->is_table_parallel_hint()) {
if (OB_FAIL(add_table_parallel_hint(stmt, query_hint, *static_cast<const ObTableParallelHint*>(hint)))) {
LOG_WARN("failed to add table parallel hint", K(ret));
}
} else if (hint->is_join_filter_hint()) {
if (OB_FAIL(add_join_filter_hint(stmt, query_hint, *static_cast<const ObJoinFilterHint*>(hint)))) {
LOG_WARN("failed to add join filter hint", K(ret));
}
} else if (hint->is_join_hint()) {
if (OB_FAIL(add_join_hint(stmt, query_hint, *static_cast<const ObJoinHint*>(hint)))) {
LOG_WARN("failed to add join hint", K(ret));
}
} else if (hint->is_table_dynamic_sampling_hint()) {
if (OB_FAIL(add_table_dynamic_sampling_hint(stmt, query_hint,
*static_cast<const ObTableDynamicSamplingHint*>(hint)))) {
LOG_WARN("failed to add dynamic sampling hint", K(ret));
}
} else if (hint->is_pq_subquery_hint()) {
if (OB_FAIL(normal_hints_.push_back(hint))) {
LOG_WARN("failed to push back", K(ret));
}
} else {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected hint type in other_opt_hints_", K(ret), K(*hint));
}
}
if (OB_FAIL(ret)) {
} else if (OB_FAIL(init_log_table_hints(schema_guard))) {
LOG_WARN("failed to init log table hints", K(ret));
} else if (OB_FAIL(init_log_join_hints())) {
LOG_WARN("failed to init log join hints", K(ret));
}
return ret;
}
// init single table hints:
// 1. index hints;
// 2. imc hints;
// 3. table parallel hints;
// 4. dynamic sampling hint;
int ObLogPlanHint::init_log_table_hints(ObSqlSchemaGuard &schema_guard)
{
int ret = OB_SUCCESS;
int64_t valid_cnt = 0;
for (int64_t i = 0; OB_SUCC(ret) && i < table_hints_.count(); ++i) {
if (OB_FAIL(table_hints_.at(i).init_index_hints(schema_guard))) {
LOG_WARN("failed to init index hint for table.", K(ret));
} else if (!table_hints_.at(i).is_valid()) {
/* do nothing */
} else if (valid_cnt != i && OB_FAIL(table_hints_.at(valid_cnt).assign(table_hints_.at(i)))) {
LOG_WARN("failed to assign log index hint.", K(ret));
} else {
++valid_cnt;
}
}
if (OB_SUCC(ret)) {
ObOptimizerUtil::revert_items(table_hints_, valid_cnt);
}
return ret;
}
int ObLogPlanHint::add_index_hint(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObIndexHint &index_hint)
{
int ret = OB_SUCCESS;
LogTableHint *log_table_hint = NULL;
if (OB_FAIL(get_log_table_hint_for_update(stmt, query_hint, index_hint.get_table(),
true, log_table_hint))) {
LOG_WARN("failed to get log table hint by hint", K(ret));
} else if (NULL == log_table_hint) {
/* do nothing */
} else if (T_USE_DAS_HINT == index_hint.get_hint_type()) {
if (NULL == log_table_hint->use_das_hint_ || index_hint.is_enable_hint()) {
log_table_hint->use_das_hint_ = &index_hint;
}
} else if (T_USE_COLUMN_STORE_HINT == index_hint.get_hint_type()) {
if (NULL == log_table_hint->use_column_store_hint_ || index_hint.is_enable_hint()) {
log_table_hint->use_column_store_hint_ = &index_hint;
}
} else if (OB_FAIL(log_table_hint->index_hints_.push_back(&index_hint))) {
LOG_WARN("failed to push back", K(ret));
}
return ret;
}
int ObLogPlanHint::add_table_parallel_hint(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObTableParallelHint &table_parallel_hint)
{
int ret = OB_SUCCESS;
LogTableHint *log_table_hint = NULL;
if (OB_FAIL(get_log_table_hint_for_update(stmt, query_hint, table_parallel_hint.get_table(),
true, log_table_hint))) {
LOG_WARN("failed to get log table hint by hint", K(ret));
} else if (NULL == log_table_hint) {
/* do nothing */
} else if (NULL == log_table_hint->parallel_hint_ ||
table_parallel_hint.get_parallel() > log_table_hint->parallel_hint_->get_parallel()) {
log_table_hint->parallel_hint_ = &table_parallel_hint;
}
return ret;
}
int ObLogPlanHint::add_table_dynamic_sampling_hint(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObTableDynamicSamplingHint &table_ds_hint)
{
int ret = OB_SUCCESS;
LogTableHint *log_table_hint = NULL;
if (OB_FAIL(get_log_table_hint_for_update(stmt, query_hint, table_ds_hint.get_table(),
true, log_table_hint))) {
LOG_WARN("failed to get log table hint by hint", K(ret));
} else if (NULL == log_table_hint) {
/* do nothing */
} else if (NULL == log_table_hint->dynamic_sampling_hint_ && !log_table_hint->is_ds_hint_conflict_) {
log_table_hint->dynamic_sampling_hint_ = &table_ds_hint;
} else if (log_table_hint->dynamic_sampling_hint_->get_dynamic_sampling() != table_ds_hint.get_dynamic_sampling() ||
log_table_hint->dynamic_sampling_hint_->get_sample_block_cnt() != table_ds_hint.get_sample_block_cnt()) {
//conflict will cause reset origin state compatible Oracle.
log_table_hint->dynamic_sampling_hint_ = NULL;
log_table_hint->is_ds_hint_conflict_ = true;
}
return ret;
}
int ObLogPlanHint::add_join_filter_hint(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObJoinFilterHint &join_filter_hint)
{
int ret = OB_SUCCESS;
LogTableHint *log_table_hint = NULL;
if (OB_FAIL(get_log_table_hint_for_update(stmt, query_hint, join_filter_hint.get_filter_table(),
false, log_table_hint))) {
LOG_WARN("failed to get log table hint by hint", K(ret));
} else if (NULL == log_table_hint) {
/* do nothing */
} else if (OB_FAIL(log_table_hint->add_join_filter_hint(stmt, query_hint, join_filter_hint))) {
LOG_WARN("failed to add join filter hint", K(ret));
}
return ret;
}
int ObLogPlanHint::get_log_table_hint_for_update(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObTableInHint &table,
const bool basic_table_only,
LogTableHint *&log_table_hint)
{
int ret = OB_SUCCESS;
TableItem *table_item = NULL;
log_table_hint = NULL;
if (OB_FAIL(query_hint.get_table_item_by_hint_table(stmt, table, table_item))) {
LOG_WARN("failed to get table item by hint table", K(ret));
} else if (NULL != table_item && (table_item->is_basic_table() || !basic_table_only)) {
for (int64_t i = 0; NULL == log_table_hint && i < table_hints_.count(); ++i) {
if (OB_ISNULL(table_hints_.at(i).table_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(i), K(table_hints_));
} else if (table_hints_.at(i).table_->table_id_ == table_item->table_id_) {
log_table_hint = &table_hints_.at(i);
}
}
if (NULL == log_table_hint) {
if (OB_ISNULL(log_table_hint = table_hints_.alloc_place_holder())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("Allocate log index hint from array error", K(ret));
} else {
log_table_hint->table_ = table_item;
}
}
}
return ret;
}
int ObLogPlanHint::add_join_hint(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObJoinHint &join_hint)
{
int ret = OB_SUCCESS;
LogJoinHint *log_join_hint = NULL;
ObRelIds join_tables;
if (OB_FAIL(query_hint.get_relids_from_hint_tables(stmt, join_hint.get_tables(), join_tables))) {
LOG_WARN("failed to get relids from hint tables", K(ret), K(join_hint.get_tables()));
} else if (join_tables.is_empty()) {
LOG_TRACE("get invalid join hint", K(ret), K(join_tables), K(join_hint));
} else {
LOG_TRACE("get valid join hint", K(join_hint));
log_join_hint = NULL;
for (int64_t i = 0; NULL == log_join_hint && i < join_hints_.count(); ++i) {
if (join_tables.equal(join_hints_.at(i).join_tables_)) {
log_join_hint = &join_hints_.at(i);
}
}
if (NULL == log_join_hint) {
if (OB_ISNULL(log_join_hint = join_hints_.alloc_place_holder())) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("Allocate log join hint from array error", K(ret));
} else if (log_join_hint->join_tables_.add_members(join_tables)) {
LOG_WARN("failed to add members", K(ret));
}
}
if (OB_SUCC(ret) && OB_FAIL(log_join_hint->add_join_hint(join_hint))) {
LOG_WARN("failed to add join hint", K(ret), K(join_hint));
}
}
return ret;
}
// init log join hint for use join hint
int ObLogPlanHint::init_log_join_hints()
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < join_hints_.count(); ++i) {
if (OB_FAIL(join_hints_.at(i).init_log_join_hint())) {
LOG_WARN("failed to init log join hint", K(ret));
}
}
return ret;
}
const ObHint *ObLogPlanHint::get_normal_hint(ObItemType hint_type) const
{
const ObHint *hint = NULL;
for (int64_t i = 0; NULL == hint && i < normal_hints_.count(); ++i) {
if (OB_ISNULL(normal_hints_.at(i))) {
/* do nothing */
} else if (normal_hints_.at(i)->get_hint_type() == hint_type) {
hint = normal_hints_.at(i);
}
}
return hint;
}
bool ObLogPlanHint::has_enable_hint(ObItemType hint_type) const
{
const ObHint *cur_hint = get_normal_hint(hint_type);
return NULL != cur_hint && cur_hint->is_enable_hint();
}
bool ObLogPlanHint::has_disable_hint(ObItemType hint_type) const
{
const ObHint *cur_hint = get_normal_hint(hint_type);
return NULL != cur_hint ? cur_hint->is_disable_hint() : is_outline_data_;
}
int ObLogPlanHint::get_aggregation_info(bool &force_use_hash,
bool &force_use_merge,
bool &force_part_sort,
bool &force_normal_sort) const
{
int ret = OB_SUCCESS;
force_use_hash = false;
force_use_merge = false;
force_part_sort = false;
force_normal_sort = false;
const ObAggHint *agg_hint = static_cast<const ObAggHint*>(get_normal_hint(T_USE_HASH_AGGREGATE));
if (NULL != agg_hint) {
force_use_hash = agg_hint->is_enable_hint();
force_use_merge = agg_hint->is_disable_hint();
force_part_sort = agg_hint->force_partition_sort();
force_normal_sort = agg_hint->force_normal_sort();
if (force_use_merge && !force_part_sort && !force_normal_sort && is_outline_data_) {
force_normal_sort = true;
}
} else if (is_outline_data_) {
force_use_merge = true;
force_normal_sort = true;
}
return ret;
}
const ObWindowDistHint *ObLogPlanHint::get_window_dist() const
{
return static_cast<const ObWindowDistHint*>(
get_normal_hint(T_PQ_DISTRIBUTE_WINDOW));
}
const LogTableHint *ObLogPlanHint::get_log_table_hint(uint64_t table_id) const
{
const LogTableHint *log_table_hint = NULL;
for (int64_t i = 0; NULL == log_table_hint && i < table_hints_.count(); ++i) {
if (NULL != table_hints_.at(i).table_
&& table_hints_.at(i).table_->table_id_ == table_id) {
log_table_hint = &table_hints_.at(i);
}
}
return log_table_hint;
}
const LogTableHint* ObLogPlanHint::get_index_hint(uint64_t table_id) const
{
const LogTableHint *log_table_hint = get_log_table_hint(table_id);
return NULL != log_table_hint && !log_table_hint->index_hints_.empty() ? log_table_hint : NULL;
}
int64_t ObLogPlanHint::get_parallel(uint64_t table_id) const
{
int64_t table_parallel = ObGlobalHint::UNSET_PARALLEL;
const LogTableHint *log_table_hint = get_log_table_hint(table_id);
if (NULL == log_table_hint || NULL == log_table_hint->parallel_hint_) {
table_parallel = is_outline_data_ ? ObGlobalHint::DEFAULT_PARALLEL : ObGlobalHint::UNSET_PARALLEL;
} else {
table_parallel = log_table_hint->parallel_hint_->get_parallel();
}
return table_parallel;
}
int ObLogPlanHint::check_use_das(uint64_t table_id, bool &force_das, bool &force_no_das) const
{
int ret = OB_SUCCESS;
force_das = false;
force_no_das = false;
const LogTableHint *log_table_hint = get_log_table_hint(table_id);
const ObHint *hint = NULL == log_table_hint ? NULL : log_table_hint->use_das_hint_;
if (NULL != hint) {
force_das = hint->is_enable_hint();
force_no_das = hint->is_disable_hint();
} else if (is_outline_data_) {
force_no_das = true;
}
return ret;
}
int ObLogPlanHint::check_use_column_store(uint64_t table_id, bool &force_column_store, bool &force_no_column_store) const
{
int ret = OB_SUCCESS;
force_column_store = false;
force_no_column_store = false;
const LogTableHint *log_table_hint = get_log_table_hint(table_id);
const ObHint *hint = NULL == log_table_hint ? NULL : log_table_hint->use_column_store_hint_;
if (NULL != hint) {
force_column_store = hint->is_enable_hint();
force_no_column_store = hint->is_disable_hint();
} else if (is_outline_data_) {
force_no_column_store = true;
}
return ret;
}
int ObLogPlanHint::check_use_skip_scan(uint64_t table_id,
uint64_t index_id,
bool &force_skip_scan,
bool &force_no_skip_scan) const
{
int ret = OB_SUCCESS;
force_skip_scan = false;
force_no_skip_scan = false;
const LogTableHint *log_table_hint = get_log_table_hint(table_id);
int64_t pos = OB_INVALID_INDEX;
if (NULL != log_table_hint &&
ObOptimizerUtil::find_item(log_table_hint->index_list_, index_id, &pos)) {
const ObIndexHint *hint = NULL;
if (OB_UNLIKELY(pos >= log_table_hint->index_hints_.count() || pos < 0)
|| OB_ISNULL(hint = log_table_hint->index_hints_.at(pos))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected pos", K(ret), K(pos), K(log_table_hint->index_hints_.count()), K(hint));
} else {
force_skip_scan = hint->use_skip_scan();
force_no_skip_scan = !force_skip_scan && hint->is_use_index_hint();
}
}
if (OB_SUCC(ret) && !force_skip_scan && !force_no_skip_scan && is_outline_data_) {
force_no_skip_scan = true;
}
return ret;
}
const ObTableDynamicSamplingHint *ObLogPlanHint::get_dynamic_sampling_hint(uint64_t table_id) const
{
const LogTableHint *log_table_hint = get_log_table_hint(table_id);
return NULL == log_table_hint ? NULL : log_table_hint->dynamic_sampling_hint_;
}
int ObLogPlanHint::check_use_join_filter(uint64_t filter_table_id,
const ObRelIds &left_tables,
bool part_join_filter,
bool config_disable,
bool &can_use,
const ObJoinFilterHint *&force_hint) const
{
int ret = OB_SUCCESS;
const LogTableHint *log_table_hint = get_log_table_hint(filter_table_id);
const ObJoinFilterHint *hint = NULL;
if (NULL != log_table_hint &&
OB_FAIL(log_table_hint->get_join_filter_hint(left_tables, part_join_filter, hint))) {
LOG_WARN("failed to get join filter hint", K(ret));
} else if (NULL != hint) {
can_use = hint->is_enable_hint();
force_hint = can_use ? hint : NULL;
} else if (is_outline_data_) {
can_use = false;
force_hint = NULL;
} else {
can_use = !config_disable;
force_hint = NULL;
}
return ret;
}
int ObLogPlanHint::get_pushdown_join_filter_hints(uint64_t filter_table_id,
const ObRelIds &left_tables,
bool config_disable,
JoinFilterPushdownHintInfo& info) const
{
int ret = OB_SUCCESS;
const LogTableHint *log_table_hint = get_log_table_hint(filter_table_id);
info.filter_table_id_ = filter_table_id;
info.config_disable_ = config_disable;
if (NULL == log_table_hint) {
} else if(OB_FAIL(log_table_hint->get_join_filter_hints(left_tables, false,
info.join_filter_hints_))) {
LOG_WARN("failed to get join filter hints", K(ret));
} else if (OB_FAIL(log_table_hint->get_join_filter_hints(left_tables, true,
info.part_join_filter_hints_))) {
LOG_WARN("failed to get join filter hints", K(ret));
}
return ret;
}
const LogJoinHint *ObLogPlanHint::get_join_hint(const ObRelIds &join_tables) const
{
const LogJoinHint *log_join_hint = NULL;
for (int64_t i = 0; NULL == log_join_hint && i < join_hints_.count(); ++i) {
if (join_tables.equal(join_hints_.at(i).join_tables_)) {
log_join_hint = &join_hints_.at(i);
}
}
return log_join_hint;
}
SetAlgo ObLogPlanHint::get_valid_set_algo() const
{
SetAlgo set_algo = INVALID_SET_ALGO; // default valid, can use MERGE_SET and HASH_SET
const ObHint *cur_hint = get_normal_hint(T_USE_HASH_SET);
if (NULL == cur_hint) {
set_algo = is_outline_data_ ? MERGE_SET : INVALID_SET_ALGO;
} else if (cur_hint->is_enable_hint()) {
set_algo = HASH_SET;
} else if (cur_hint->is_disable_hint()) {
set_algo = MERGE_SET;
}
return set_algo;
}
DistAlgo ObLogPlanHint::get_valid_set_dist_algo(int64_t *random_none_idx /* default NULL */ ) const
{
DistAlgo set_dist_algo = DistAlgo::DIST_INVALID_METHOD;
const ObPQSetHint *pq_set_hint = static_cast<const ObPQSetHint*>(get_normal_hint(T_PQ_SET));
if (NULL == pq_set_hint) {
set_dist_algo = is_outline_data_ ? DistAlgo::DIST_BASIC_METHOD
: DistAlgo::DIST_INVALID_METHOD;
} else {
int64_t idx = OB_INVALID_INDEX;
set_dist_algo = pq_set_hint->get_dist_algo(idx);
if (NULL != random_none_idx) {
*random_none_idx = idx;
}
}
return set_dist_algo;
}
int ObLogPlanHint::check_valid_set_left_branch(const ObSelectStmt *select_stmt,
bool &hint_valid,
bool &need_swap) const
{
int ret = OB_SUCCESS;
hint_valid = false;
need_swap = false;
const ObPQSetHint *pq_set_hint = NULL;
ObString left_child;
ObString right_child;
if (OB_UNLIKELY(!select_stmt->is_set_stmt()
|| !select_stmt->is_set_distinct()
|| 2 > select_stmt->get_set_query().count())
|| OB_ISNULL(select_stmt->get_set_query(0))
|| OB_ISNULL(select_stmt->get_set_query(1))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected set_op stmt", K(ret), K(select_stmt));
} else if (NULL == (pq_set_hint = static_cast<const ObPQSetHint*>(get_normal_hint(T_PQ_SET)))) {
hint_valid = is_outline_data_;
need_swap = false;
} else if (pq_set_hint->get_left_branch().empty()) {
hint_valid = true;
need_swap = false;
} else if (OB_FAIL(select_stmt->get_set_query(0)->get_qb_name(left_child))
|| OB_FAIL(select_stmt->get_set_query(1)->get_qb_name(right_child))) {
LOG_WARN("failed to get qb name", K(ret));
} else if (0 == pq_set_hint->get_left_branch().case_compare(left_child)) {
hint_valid = true;
need_swap = false;
} else if (0 == pq_set_hint->get_left_branch().case_compare(right_child)) {
hint_valid = true;
need_swap = true;
} else {
hint_valid = false;
need_swap = false;
}
return ret;
}
int ObLogPlanHint::get_valid_pq_subquery_hint(const ObIArray<ObString> &sub_qb_names,
const ObPQSubqueryHint *&explicit_hint,
const ObPQSubqueryHint *&implicit_hint) const
{
int ret = OB_SUCCESS;
for (int64_t i = 0; NULL == explicit_hint && i < normal_hints_.count(); ++i) {
if (NULL != normal_hints_.at(i) && normal_hints_.at(i)->get_hint_type() == T_PQ_SUBQUERY) {
const ObPQSubqueryHint *cur_hint = static_cast<const ObPQSubqueryHint*>(normal_hints_.at(i));
if (NULL == explicit_hint && cur_hint->is_match_subplans(sub_qb_names)) {
explicit_hint = cur_hint;
} else if (NULL == implicit_hint && cur_hint->get_sub_qb_names().empty()) {
implicit_hint = cur_hint;
}
}
}
return ret;
}
DistAlgo ObLogPlanHint::get_valid_pq_subquery_dist_algo(const ObIArray<ObString> &sub_qb_names,
const bool implicit_allowed) const
{
int ret = OB_SUCCESS; // ignore this ret
DistAlgo dist_algo = DistAlgo::DIST_INVALID_METHOD;
const ObPQSubqueryHint *explicit_hint = NULL;
const ObPQSubqueryHint *implicit_hint = NULL;
if (OB_FAIL(get_valid_pq_subquery_hint(sub_qb_names, explicit_hint, implicit_hint))) {
LOG_WARN("failed to get valid subplan filter hint", K(ret));
} else if (NULL != explicit_hint) {
dist_algo = explicit_hint->get_dist_algo();
} else if (is_outline_data_) {
dist_algo = DistAlgo::DIST_BASIC_METHOD;
} else if (NULL != implicit_hint && implicit_allowed) {
dist_algo = implicit_hint->get_dist_algo();
}
return dist_algo;
}
// generate spm evolution plan, throw a error code when can not get valid hint
int ObLogPlanHint::check_status() const
{
int ret = OB_SUCCESS;
#ifdef OB_BUILD_SPM
if (is_spm_evolution_) {
ret = OB_OUTLINE_NOT_REPRODUCIBLE;
LOG_WARN("failed to generate plan use outline data for spm evolution", K(ret));
}
#endif
return ret;
}
bool ObLogPlanHint::is_spm_evolution() const
{
bool bret = false;
#ifdef OB_BUILD_SPM
bret = is_spm_evolution_;
#endif
return bret;
}
int LogLeadingHint::init_leading_info(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObHint *hint)
{
int ret = OB_SUCCESS;
reset();
if (NULL == hint) {
/* do nothing */
} else if (OB_UNLIKELY(!hint->is_join_order_hint())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect hint type", K(ret), K(*hint));
} else {
ObRelIds table_set;
hint_ = static_cast<const ObJoinOrderHint*>(hint);
if (hint_->is_ordered_hint() &&
OB_FAIL(init_leading_info_from_ordered_hint(stmt))) {
LOG_TRACE("failed to init leading info from ordered hint.", K(ret));
} else if (!hint_->is_ordered_hint() &&
OB_FAIL(init_leading_info_from_leading_hint(stmt, query_hint, hint_->get_table(), table_set))) {
LOG_TRACE("failed to init leading info from leading hint.", K(ret));
} else if (NULL == hint_) {
leading_tables_.reuse();
leading_infos_.reuse();
} else {
LOG_TRACE("succeed to get leading infos", K(*this));
}
}
return ret;
}
int LogLeadingHint::init_leading_info_from_leading_hint(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObLeadingTable &cur_table,
ObRelIds& table_set)
{
int ret = OB_SUCCESS;
LeadingInfo leading_info;
if (NULL != cur_table.table_) {
int32_t index = OB_INVALID_INDEX;
if (OB_FAIL(query_hint.get_table_bit_index_by_hint_table(stmt, *cur_table.table_, index))) {
LOG_WARN("failed to get table id", K(ret));
} else if (OB_INVALID_INDEX == index || leading_tables_.has_member(index)) {
hint_ = NULL;
LOG_WARN("failed to get table bit index by hint table", K(index), K(*cur_table.table_),
K(stmt.get_table_items()));
} else if (OB_FAIL(leading_tables_.add_member(index))
|| OB_FAIL(table_set.add_member(index))) {
LOG_WARN("failed to add members", K(ret));
}
} else if (OB_ISNULL(cur_table.left_table_) || OB_ISNULL(cur_table.right_table_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null.", K(ret), K(cur_table.left_table_), K(cur_table.right_table_));
} else if (OB_FAIL(SMART_CALL(init_leading_info_from_leading_hint(stmt, query_hint,
*cur_table.left_table_,
leading_info.left_table_set_)))) {
LOG_WARN("failed to init leading info from leading", K(ret));
} else if (NULL == hint_) {
/* do nothing */
} else if (OB_FAIL(SMART_CALL(init_leading_info_from_leading_hint(stmt, query_hint,
*cur_table.right_table_,
leading_info.right_table_set_)))) {
LOG_WARN("failed to init leading info from leading", K(ret));
} else if (NULL == hint_) {
/* do nothing */
} else if (OB_FAIL(leading_info.table_set_.add_members(leading_info.left_table_set_))
|| OB_FAIL(leading_info.table_set_.add_members(leading_info.right_table_set_))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(leading_infos_.push_back(leading_info))) {
LOG_WARN("failed to push back hint info", K(ret));
} else if (OB_FAIL(table_set.add_members(leading_info.table_set_))) {
LOG_WARN("failed to add table ids", K(ret));
}
return ret;
}
/**
* for ordered hint, init leading hint info by the ordering of tables in stmt
*/
int LogLeadingHint::init_leading_info_from_ordered_hint(const ObDMLStmt &stmt)
{
int ret = OB_SUCCESS;
const ObIArray<FromItem> &from_items = stmt.get_from_items();
const ObIArray<SemiInfo*> &semi_infos = stmt.get_semi_infos();
SemiInfo *semi_info = NULL;
ObRelIds leading_tables;
const int64_t N = from_items.count() + semi_infos.count();
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
LeadingInfo leading_info;
if (i < from_items.count()) {
const FromItem &from_item = from_items.at(i);
TableItem *table_item = from_item.is_joined_
? stmt.get_joined_table(from_item.table_id_)
: stmt.get_table_item_by_id(from_item.table_id_);
if (OB_FAIL(init_leading_info_from_table(stmt, leading_infos_,
table_item, leading_info.right_table_set_))) {
LOG_WARN("failed to init leading infos from table.", K(ret));
}
} else if (OB_ISNULL(semi_info = semi_infos.at(i - from_items.count()))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null semi info", K(ret));
} else if (OB_FAIL(leading_info.right_table_set_.add_member(
stmt.get_table_bit_index(semi_info->right_table_id_)))) {
LOG_WARN("failed to add members", K(ret));
}
if (i == 0) {
ret = leading_tables.add_members(leading_info.right_table_set_);
} else if (OB_FAIL(leading_info.left_table_set_.add_members(leading_tables))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(leading_tables.add_members(leading_info.right_table_set_))) {
LOG_WARN("failed to get table ids", K(ret));
} else if (OB_FAIL(leading_info.table_set_.add_members(leading_tables))) {
LOG_WARN("failed to add table ids", K(ret));
} else if (OB_FAIL(leading_infos_.push_back(leading_info))) {
LOG_WARN("failed to push back hint info", K(ret));
}
}
if (OB_SUCC(ret) && OB_FAIL(leading_tables_.add_members(leading_tables))) {
LOG_WARN("failed to get table ids", K(ret));
}
return ret;
}
/**
* init leading hint info for table item
*/
int LogLeadingHint::init_leading_info_from_table(const ObDMLStmt &stmt,
ObIArray<LeadingInfo> &leading_infos,
TableItem *table,
ObRelIds &table_set)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(table)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpect null table item", K(ret));
} else if (!table->is_joined_table()) {
if (OB_FAIL(table_set.add_member(stmt.get_table_bit_index(table->table_id_)))) {
LOG_WARN("failed to add members", K(ret));
}
} else {
LeadingInfo leading_info;
JoinedTable *joined_table = static_cast<JoinedTable*>(table);
if (OB_FAIL(SMART_CALL(init_leading_info_from_table(stmt, leading_infos,
joined_table->left_table_,
leading_info.left_table_set_)))) {
LOG_WARN("failed to get leading hint info", K(ret));
} else if (OB_FAIL(SMART_CALL(init_leading_info_from_table(stmt, leading_infos,
joined_table->right_table_,
leading_info.right_table_set_)))) {
LOG_WARN("failed to get leading hint info", K(ret));
} else if (OB_FAIL(leading_info.table_set_.add_members(leading_info.left_table_set_))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(leading_info.table_set_.add_members(leading_info.right_table_set_))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(table_set.add_members(leading_info.table_set_))) {
LOG_WARN("failed to add members", K(ret));
} else if (OB_FAIL(leading_infos.push_back(leading_info))) {
LOG_WARN("failed to push back hint info", K(ret));
}
}
return ret;
}
int LogJoinHint::assign(const LogJoinHint &other)
{
int ret = OB_SUCCESS;
local_methods_ = other.local_methods_;
dist_methods_ = other.dist_methods_;
slave_mapping_ = other.slave_mapping_;
nl_material_ = other.nl_material_;
join_tables_ = other.join_tables_;
if (OB_FAIL(local_method_hints_.assign(other.local_method_hints_))) {
LOG_WARN("fail to assign local method hints", K(ret));
} else if (OB_FAIL(dist_method_hints_.assign(other.dist_method_hints_))) {
LOG_WARN("fail to assign dist method hints", K(ret));
}
return ret;
}
int LogJoinHint::add_join_hint(const ObJoinHint &join_hint)
{
int ret = OB_SUCCESS;
switch(join_hint.get_hint_type()) {
case T_USE_NL:
case T_USE_MERGE:
case T_USE_HASH: {
if (OB_FAIL(local_method_hints_.push_back(&join_hint))) {
LOG_WARN("fail to push back join hint", K(ret), K(join_hint));
}
break;
}
case T_USE_NL_MATERIALIZATION: {
//if both use_material and no_use_material, no_use_material worked.
if (NULL == nl_material_ || (join_hint.is_disable_hint() && nl_material_->is_enable_hint())) {
nl_material_ = &join_hint;
}
break;
}
case T_PQ_DISTRIBUTE: {
if (dist_methods_ & join_hint.get_dist_algo()) {
/* do nothing */
} else if (OB_FAIL(dist_method_hints_.push_back(&join_hint))) {
LOG_WARN("fail to push back join hint", K(ret), K(join_hint));
} else {
dist_methods_ |= join_hint.get_dist_algo();
}
break;
}
case T_PQ_MAP: {
if (NULL == slave_mapping_) {
slave_mapping_ = &join_hint;
}
break;
}
default: {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected join hint type", K(ret), K(join_hint));
}
}
return ret;
}
int LogJoinHint::init_log_join_hint()
{
int ret = OB_SUCCESS;
local_methods_ = JoinAlgo::INVALID_JOIN_ALGO;
ObSEArray<const ObJoinHint*, 4> all_hints;
if (OB_FAIL(all_hints.assign(local_method_hints_))) {
LOG_WARN("fail to assign local method join hints", K(ret));
} else {
#define ADD_USE_JOIN_HINT(join_algo) { \
int64_t &cur_methods = join_hint->is_enable_hint() ? use_methods : no_use_methods; \
if (!(cur_methods & join_algo) && OB_FAIL(local_method_hints_.push_back(join_hint))) { \
LOG_WARN("fail to push back join hint", K(ret), K(*join_hint)); \
} else { cur_methods |= join_algo; }} \
local_method_hints_.reuse();
int64_t use_methods = JoinAlgo::INVALID_JOIN_ALGO;
int64_t no_use_methods = JoinAlgo::INVALID_JOIN_ALGO;
const ObJoinHint *join_hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && local_method_hints_.count() < 6
&& i < all_hints.count(); ++i) {
if (OB_ISNULL(join_hint = all_hints.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected NULL", K(ret), K(all_hints));
} else {
switch(join_hint->get_hint_type()) {
case T_USE_NL: ADD_USE_JOIN_HINT(NESTED_LOOP_JOIN); break;
case T_USE_HASH: ADD_USE_JOIN_HINT(HASH_JOIN); break;
case T_USE_MERGE: ADD_USE_JOIN_HINT(MERGE_JOIN); break;
default: {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected join hint type", K(ret), K(join_hint));
}
}
}
}
if (OB_SUCC(ret)) {
use_methods = JoinAlgo::INVALID_JOIN_ALGO == use_methods ? NESTED_LOOP_JOIN | HASH_JOIN | MERGE_JOIN
: use_methods;
local_methods_ = use_methods & ~no_use_methods;
LOG_DEBUG("finish init local methods", K(local_methods_), K(all_hints),
K(local_method_hints_));
}
}
return ret;
}
int LogTableHint::assign(const LogTableHint &other)
{
int ret = OB_SUCCESS;
table_ = other.table_;
parallel_hint_ = other.parallel_hint_;
use_das_hint_ = other.use_das_hint_;
use_column_store_hint_ = other.use_column_store_hint_;
if (OB_FAIL(index_list_.assign(other.index_list_))) {
LOG_WARN("failed to assign index list", K(ret));
} else if (OB_FAIL(index_hints_.assign(other.index_hints_))) {
LOG_WARN("failed to assign hints", K(ret));
} else if (OB_FAIL(join_filter_hints_.assign(other.join_filter_hints_))) {
LOG_WARN("failed to assign index list", K(ret));
} else if (OB_FAIL(left_tables_.assign(other.left_tables_))) {
LOG_WARN("failed to assign hints", K(ret));
}
return ret;
}
int LogTableHint::init_index_hints(ObSqlSchemaGuard &schema_guard)
{
int ret = OB_SUCCESS;
uint64_t tids[OB_MAX_INDEX_PER_TABLE + 1];
int64_t table_index_count = OB_MAX_INDEX_PER_TABLE + 1;
if (OB_ISNULL(table_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected log index hint", K(ret), K(this));
} else if (index_hints_.empty()) {
/* do nothing */
} else if (OB_FAIL(schema_guard.get_can_read_index_array(table_->ref_id_,
tids,
table_index_count,
false,
table_->access_all_part(),
false /*domain index*/,
false /*spatial index*/))) {
LOG_WARN("failed to get can read index", K(ret));
} else if (table_index_count > OB_MAX_INDEX_PER_TABLE) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Table index count is bigger than OB_MAX_INDEX_PER_TABLE", K(ret), K(table_index_count));
} else {
LOG_TRACE("get readable index", K(table_index_count));
const share::schema::ObTableSchema *index_schema = NULL;
ObSEArray<uint64_t, 4> index_list;
ObSEArray<uint64_t, 4> no_index_list;
ObSEArray<const ObIndexHint*, 4> index_hints;
ObSEArray<const ObIndexHint*, 4> no_index_hints;
for (int64_t i = -1; OB_SUCC(ret) && i < table_index_count; ++i) {
uint64_t index_id = -1 == i ? table_->ref_id_ : tids[i];
ObString index_name;
bool is_primary_key = false;
if (-1 == i) {
is_primary_key = true;
index_name = ObIndexHint::PRIMARY_KEY;
} else if (OB_FAIL(schema_guard.get_table_schema(index_id, index_schema)) ||
OB_ISNULL(index_schema)) {
ret = OB_SCHEMA_ERROR;
LOG_WARN("fail to get table schema", K(index_id), K(ret));
} else if (index_schema->is_domain_index()) {
// just ignore domain index
} else if (OB_FAIL(index_schema->get_index_name(index_name))) {
LOG_WARN("fail to get index name", K(index_name), K(ret));
}
if (OB_SUCC(ret) && (!index_name.empty())) {
int64_t no_index_hint_pos = OB_INVALID_INDEX;
int64_t index_hint_pos = OB_INVALID_INDEX;
int64_t index_ss_hint_pos = OB_INVALID_INDEX;
const uint64_t N = index_hints_.count();
const ObIndexHint *index_hint = NULL;
for (int64_t hint_i = 0; OB_SUCC(ret) && hint_i < N; ++hint_i) {
if (OB_ISNULL(index_hint = index_hints_.at(hint_i)) ||
OB_UNLIKELY(!index_hint->is_access_path_hint())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null index hint", K(ret), K(index_hint));
} else if (is_primary_key && T_FULL_HINT == index_hint->get_hint_type()) {
index_hint_pos = hint_i;
} else if (0 != index_hint->get_index_name().case_compare(index_name)) {
/* do nothing */
} else if (T_NO_INDEX_HINT == index_hint->get_hint_type()) {
no_index_hint_pos = hint_i;
} else if (T_INDEX_SS_HINT == index_hint->get_hint_type()) {
index_ss_hint_pos = hint_i;
} else {
index_hint_pos = hint_i;
}
}
if (OB_FAIL(ret)) {
} else if (OB_INVALID_INDEX != no_index_hint_pos
&& (OB_INVALID_INDEX != index_ss_hint_pos
|| OB_INVALID_INDEX != index_hint_pos)) {
/* conflict full/index/index_ss and no_index hint*/
} else if (OB_INVALID_INDEX != no_index_hint_pos) {
if (OB_FAIL(no_index_list.push_back(index_id))) {
LOG_WARN("fail to push back", K(ret), K(index_id));
} else if (OB_FAIL(no_index_hints.push_back(index_hints_.at(no_index_hint_pos)))) {
LOG_WARN("fail to push back", K(ret), K(no_index_hint_pos));
}
} else if (OB_INVALID_INDEX != index_ss_hint_pos
|| OB_INVALID_INDEX != index_hint_pos) {
int64_t hint_pos = OB_INVALID_INDEX != index_ss_hint_pos
? index_ss_hint_pos : index_hint_pos;
if (OB_FAIL(index_list.push_back(index_id))) {
LOG_WARN("fail to push back", K(ret), K(index_id));
} else if (OB_FAIL(index_hints.push_back(index_hints_.at(hint_pos)))) {
LOG_WARN("fail to push back", K(ret), K(hint_pos));
}
}
}
}
if (OB_SUCC(ret)) {
if (!index_list.empty()) {
if (OB_FAIL(index_list_.assign(index_list))) {
LOG_WARN("failed to assign array", K(ret));
} else if (OB_FAIL(index_hints_.assign(index_hints))) {
LOG_WARN("failed to assign array", K(ret));
}
} else if (OB_FAIL(index_list_.assign(no_index_list))) {
LOG_WARN("failed to assign array", K(ret));
} else if (OB_FAIL(index_hints_.assign(no_index_hints))) {
LOG_WARN("failed to assign array", K(ret));
}
}
}
return ret;
}
int LogTableHint::get_join_filter_hint(const ObRelIds &left_tables,
bool part_join_filter,
const ObJoinFilterHint *&hint) const
{
int ret = OB_SUCCESS;
hint = NULL;
if (OB_UNLIKELY(left_tables.is_empty()) ||
OB_UNLIKELY(left_tables_.count() != join_filter_hints_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected params", K(ret), K(left_tables), K(left_tables_), K(join_filter_hints_));
} else {
const ObJoinFilterHint *cur_hint = NULL;
bool finish = false;
for (int64_t i = 0; OB_SUCC(ret) && !finish && i < left_tables_.count(); ++i) {
if (OB_ISNULL(cur_hint = join_filter_hints_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret));
} else if (cur_hint->is_part_join_filter_hint() != part_join_filter) {
/* do nothing */
} else if (NULL == hint && left_tables_.at(i).is_empty()) {
hint = cur_hint;
} else if (left_tables.equal(left_tables_.at(i))) {
hint = cur_hint;
finish = true;
}
}
}
return ret;
}
int LogTableHint::get_join_filter_hints(const ObRelIds &left_tables,
bool part_join_filter,
ObIArray<const ObJoinFilterHint*> &hints) const
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(left_tables.is_empty()) ||
OB_UNLIKELY(left_tables_.count() != join_filter_hints_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected params", K(ret), K(left_tables), K(left_tables_), K(join_filter_hints_));
} else {
const ObJoinFilterHint *cur_hint = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < left_tables_.count(); ++i) {
if (OB_ISNULL(cur_hint = join_filter_hints_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret));
} else if (cur_hint->is_part_join_filter_hint() != part_join_filter) {
/* do nothing */
} else if (!left_tables.equal(left_tables_.at(i))) {
/* do nothing */
} else if (OB_FAIL(hints.push_back(cur_hint))) {
LOG_WARN("failed to push back hints", K(ret));
}
}
}
return ret;
}
int LogTableHint::add_join_filter_hint(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
const ObJoinFilterHint &hint)
{
int ret = OB_SUCCESS;
ObRelIds left_tables;
const bool has_left_tables = hint.has_left_tables();
if (OB_UNLIKELY(left_tables_.count() != join_filter_hints_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected params", K(ret), K(left_tables_), K(join_filter_hints_));
} else if (has_left_tables &&
OB_FAIL(query_hint.get_relids_from_hint_tables(stmt, hint.get_left_tables(), left_tables))) {
LOG_WARN("failed to get relids from hint tables", K(ret), K(hint.get_left_tables()));
} else if (has_left_tables && left_tables.is_empty()) {
LOG_TRACE("get invalid join hint", K(ret), K(left_tables), K(hint));
} else {
bool added = false;
for (int64_t i = 0; OB_SUCC(ret) && !added && i < left_tables_.count(); ++i) {
if (OB_ISNULL(join_filter_hints_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected params", K(ret), K(join_filter_hints_.at(i)));
} else if (join_filter_hints_.at(i)->get_hint_type() == hint.get_hint_type()
&& has_left_tables == join_filter_hints_.at(i)->has_left_tables()
&& left_tables.equal(left_tables_.at(i))
&& join_filter_hints_.at(i)->get_pushdown_filter_table().equal(
hint.get_pushdown_filter_table())) {
added = true;
if (hint.is_disable_hint()) {
join_filter_hints_.at(i) = &hint;
}
}
}
if (OB_FAIL(ret) || added) {
} else if (OB_FAIL(left_tables_.push_back(left_tables))) {
LOG_TRACE("failed to push back", K(ret), K(hint), K(left_tables));
} else if (OB_FAIL(join_filter_hints_.push_back(&hint))) {
LOG_TRACE("failed to push back", K(ret), K(hint));
}
}
return ret;
}
int LogTableHint::allowed_skip_scan(const uint64_t index_id, bool &allowed) const
{
int ret = OB_SUCCESS;
allowed = false;
if (!is_use_index_hint()) {
/* do nothing */
} else if (OB_UNLIKELY(index_list_.count() != index_hints_.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected count", K(ret), K(index_list_.count()), K(index_hints_.count()));
} else {
bool find = false;
for (int64_t i = 0; OB_SUCC(ret) && !find && i < index_list_.count(); ++i) {
if (index_list_.at(i) != index_id) {
/* do nothing */
} else if (OB_ISNULL(index_hints_.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null", K(ret), K(i), K(index_hints_));
} else {
allowed = T_INDEX_SS_HINT == index_hints_.at(i)->get_hint_type();
find = true;
}
}
}
return ret;
}
int JoinFilterPushdownHintInfo::check_use_join_filter(const ObDMLStmt &stmt,
const ObQueryHint &query_hint,
uint64_t filter_table_id,
bool part_join_filter,
bool &can_use,
const ObJoinFilterHint *&force_hint) const
{
int ret = OB_SUCCESS;
const ObIArray<const ObJoinFilterHint*> &join_filters = part_join_filter ? part_join_filter_hints_ :
join_filter_hints_;
const TableItem* table_item;
ObString qb_name;
const ObJoinFilterHint* current_hint = NULL;
bool found = false;
if (OB_ISNULL(table_item = stmt.get_table_item_by_id(filter_table_id))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to get filter table from stmt", K(ret));
} else if(OB_FAIL(stmt.get_qb_name(qb_name))) {
LOG_WARN("failed to get qb name", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && !found && i < join_filters.count(); ++i) {
const ObJoinFilterHint *hint;
if (OB_ISNULL(hint = join_filters.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (0 != hint->get_pushdown_filter_table().qb_name_.case_compare(qb_name)) {
} else if (hint->get_pushdown_filter_table().is_match_table_item(query_hint.cs_type_, *table_item)) {
current_hint = hint;
if (hint->is_disable_hint()) {
found = true;
}
}
}
if (OB_FAIL(ret)) {
} else if (NULL != current_hint) {
can_use = current_hint->is_enable_hint();
force_hint = can_use ? current_hint : NULL;
} else if (query_hint.has_outline_data()) {
can_use = false;
force_hint = NULL;
} else {
can_use = !config_disable_;
force_hint = NULL;
}
return ret;
}
}//end of namespace sql
}//end of namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink