hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
2f8121bad83ca5f17ed352ba0d53ad3b6d2bc7f0
oceanbase/src/sql/optimizer/ob_sharding_info.cpp
zzg19950727 a8cc1ed620 [CP] fix set partition wise and duplicate table bug
2024-02-09 21:51:56 +00:00

1137 lines
54 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_OPT
#include "sql/optimizer/ob_sharding_info.h"
#include "share/schema/ob_table_schema.h"
#include "share/schema/ob_schema_struct.h"
#include "sql/optimizer/ob_optimizer_context.h"
#include "sql/optimizer/ob_logical_operator.h"
#include "sql/optimizer/ob_log_plan.h"
#include "sql/optimizer/ob_opt_est_utils.h"
#include "sql/resolver/dml/ob_dml_stmt.h"
#include "sql/resolver/dml/ob_raw_expr_sets.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
#include "sql/optimizer/ob_pwj_comparer.h"
using namespace oceanbase::sql;
using namespace oceanbase::common;
using namespace oceanbase::share::schema;
int ObShardingInfo::assign(const ObShardingInfo &other)
{
int ret = OB_SUCCESS;
part_level_ = other.part_level_;
part_func_type_ = other.part_func_type_;
subpart_func_type_ = other.subpart_func_type_;
part_num_ = other.part_num_;
location_type_ = other.location_type_;
phy_table_location_info_ = other.phy_table_location_info_;
partition_array_ = other.partition_array_;
can_reselect_replica_ = other.can_reselect_replica_;
is_partition_single_ = other.is_partition_single_;
is_subpartition_sinlge_ = other.is_subpartition_sinlge_;
if (OB_FAIL(partition_keys_.assign(other.partition_keys_))) {
LOG_WARN("failed to assign exprs", K(ret));
} else if (OB_FAIL(sub_partition_keys_.assign(other.sub_partition_keys_))) {
LOG_WARN("failed to assign exprs", K(ret));
} else if (OB_FAIL(part_func_exprs_.assign(other.part_func_exprs_))) {
LOG_WARN("failed to assign exprs", K(ret));
} else if (OB_FAIL(all_tablet_ids_.assign(other.all_tablet_ids_))) {
LOG_WARN("failed to assign partition ids");
} else if (OB_FAIL(all_partition_indexes_.assign(other.all_partition_indexes_))) {
LOG_WARN("failed to assign all partitions", K(ret));
} else if (OB_FAIL(all_subpartition_indexes_.assign(other.all_subpartition_indexes_))) {
LOG_WARN("failed to assign all subpartitions", K(ret));
} else { /*do nothing*/ }
return ret;
}
int ObShardingInfo::init_partition_info(ObOptimizerContext &ctx,
const ObDMLStmt &stmt,
const uint64_t table_id,
const uint64_t ref_table_id,
const ObCandiTableLoc &phy_table_location_info)
{
int ret = OB_SUCCESS;
ObSqlSchemaGuard *schema_guard = NULL;
const ObTableSchema *table_schema = NULL;
if (OB_ISNULL(schema_guard = ctx.get_sql_schema_guard())) {
ret = OB_SCHEMA_ERROR;
LOG_WARN("failed to get table schema", K(ref_table_id));
} else if (OB_FAIL(schema_guard->get_table_schema(table_id, ref_table_id, &stmt, table_schema))) {
ret = OB_SCHEMA_ERROR;
LOG_WARN("failed to get table schema", K(ref_table_id));
} else if (OB_ISNULL(table_schema)) {
ret = OB_SCHEMA_ERROR;
LOG_WARN("failed to get table schema", K(ref_table_id));
}
if (OB_SUCC(ret)) {
part_num_ = table_schema->get_part_option().get_part_num();
part_level_ = table_schema->get_part_level();
if (PARTITION_LEVEL_ZERO == part_level_) {
//no partition expr
} else if (PARTITION_LEVEL_ONE != part_level_ && PARTITION_LEVEL_TWO != part_level_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Expected part level be one or two", K(ret), K(part_num_), K(part_level_));
} else {
ObRawExpr *part_expr = NULL;
ObRawExpr *subpart_expr = NULL;
part_func_type_ = table_schema->get_part_option().get_part_func_type();
partition_array_ = table_schema->get_part_array();
if (OB_ISNULL(part_expr = stmt.get_part_expr(table_id, ref_table_id))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("There is no part expr in stmt", K(table_id), K(ret));
} else if (OB_FAIL(part_func_exprs_.push_back(part_expr))) {
LOG_WARN("Failed to push back to part expr");
} else if (OB_FAIL(set_partition_key(part_expr, part_func_type_, partition_keys_))) {
LOG_WARN("Failed to set partition key", K(ret), K(table_id), K(ref_table_id));
} else if (PARTITION_LEVEL_TWO == part_level_) {
subpart_func_type_ = table_schema->get_sub_part_option().get_part_func_type();
if (OB_ISNULL(subpart_expr = stmt.get_subpart_expr(table_id, ref_table_id))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("There is no subpart expr in stmt", K(ret));
} else if (OB_FAIL(set_partition_key(subpart_expr, subpart_func_type_, sub_partition_keys_))) {
LOG_WARN("Failed to set sub partition key", K(ret), K(table_id), K(ref_table_id));
} else if (OB_FAIL(part_func_exprs_.push_back(subpart_expr))) {
LOG_WARN("Failed to set key partition func", K(ret), K(table_id), K(ref_table_id));
} else { }
}
}
}
if (OB_SUCC(ret)) {
if (!(is_virtual_table(ref_table_id) && OB_TBL_LOCATION_DISTRIBUTED == location_type_)) {
phy_table_location_info_ = &phy_table_location_info;
}
// virtual table can't get part idx from mock list table schema
// so don't call extract_all_partition_indexes,
// and not used pwj enhance on virtual table
if (is_virtual_table(ref_table_id)) {
// do nothing
} else if (OB_FAIL(ObPwjComparer::extract_all_partition_indexes(phy_table_location_info,
*table_schema,
all_tablet_ids_,
all_partition_indexes_,
all_subpartition_indexes_,
is_partition_single_,
is_subpartition_sinlge_))) {
LOG_WARN("failed to extract all partition indexes", K(ret));
}
}
return ret;
}
int ObShardingInfo::set_partition_key(
ObRawExpr *part_expr,
const ObPartitionFuncType part_func_type,
ObIArray<ObRawExpr*> &partition_keys)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(part_expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("Part expr should not be NULL", K(ret));
} else {
if ((PARTITION_FUNC_TYPE_KEY == part_func_type
|| PARTITION_FUNC_TYPE_KEY_IMPLICIT == part_func_type)
|| (PARTITION_FUNC_TYPE_HASH == part_func_type
&& lib::is_oracle_mode())
|| (PARTITION_FUNC_TYPE_RANGE_COLUMNS == part_func_type
&& T_OP_ROW == part_expr->get_expr_type())
|| (PARTITION_FUNC_TYPE_LIST_COLUMNS == part_func_type &&
T_OP_ROW == part_expr->get_expr_type())) {
int64_t param_num = part_expr->get_param_count();
for (int64_t i = 0; OB_SUCC(ret) && i < param_num; ++i) {
ObRawExpr *expr = part_expr->get_param_expr(i);
if (OB_FAIL(partition_keys.push_back(expr))) {
LOG_PRINT_EXPR(
WARN, "failed to add partition column expr to partition keys", expr);
} else {
LOG_PRINT_EXPR(
DEBUG, "succ to add partition column expr to partition keys", expr);
}
}
} else if (OB_FAIL(partition_keys.push_back(part_expr))) {
LOG_WARN("Failed to add partition column expr", K(ret));
} else { }
}
return ret;
}
int ObShardingInfo::is_compatible_partition_key(const ObShardingInfo *first_sharding,
const ObIArray<ObSEArray<ObRawExpr*, 8>> &first_part_keys_list,
const ObIArray<ObSEArray<ObRawExpr*, 8>> &second_part_keys_list,
bool &is_compatible)
{
int ret = OB_SUCCESS;
is_compatible = false;
if (first_part_keys_list.count() != second_part_keys_list.count() || first_part_keys_list.empty()) {
is_compatible = false;
} else {
is_compatible = true;
ObRawExpr *l_part_key = NULL;
ObRawExpr *r_part_key = NULL;
for (int64_t i = 0; OB_SUCC(ret) && is_compatible && i < first_part_keys_list.count(); i++) {
if (OB_UNLIKELY(first_part_keys_list.at(i).empty() || second_part_keys_list.at(i).empty())
|| OB_ISNULL(l_part_key = first_part_keys_list.at(i).at(0))
|| OB_ISNULL(r_part_key = second_part_keys_list.at(i).at(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(l_part_key), K(r_part_key), K(ret));
} else if (l_part_key->get_data_type() == ObDecimalIntType
&& r_part_key->get_data_type() == ObDecimalIntType
&& first_sharding != NULL) {
LOG_DEBUG("compatible partition key",
K(l_part_key->get_result_type()),
K(r_part_key->get_result_type()),
K(l_part_key->get_result_type().get_accuracy()),
K(r_part_key->get_result_type().get_accuracy()));
if (is_part_func_scale_sensitive(*first_sharding,
l_part_key->get_data_type())) {
is_compatible =
(l_part_key->get_scale() == r_part_key->get_scale());
} else {
is_compatible = true;
}
} else if (l_part_key->get_data_type() != r_part_key->get_data_type() ||
l_part_key->get_collation_type() != r_part_key->get_collation_type()) {
is_compatible = false;
}
}
}
return ret;
}
int ObShardingInfo::is_compatible_partition_key(const ObShardingInfo &first_sharding,
const ObShardingInfo &second_sharding,
bool &is_compatible)
{
int ret = OB_SUCCESS;
is_compatible = false;
ObSEArray<ObRawExpr*, 8> first_part_keys;
ObSEArray<ObRawExpr*, 8> second_part_keys;
if (OB_FAIL(first_sharding.get_all_partition_keys(first_part_keys, true))) {
LOG_WARN("failed to get sharding partition keys", K(ret));
} else if (OB_FAIL(second_sharding.get_all_partition_keys(second_part_keys, true))) {
LOG_WARN("failed to get sharding partition keys", K(ret));
} else if ((first_part_keys.count() != second_part_keys.count()) || first_part_keys.empty()) {
is_compatible = false;
} else {
is_compatible = true;
for (int64_t i = 0; OB_SUCC(ret) && is_compatible && i < first_part_keys.count(); i++) {
if (OB_ISNULL(first_part_keys.at(i)) || OB_ISNULL(second_part_keys.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(first_part_keys.at(i)), K(second_part_keys.at(i)), K(ret));
} else if (first_part_keys.at(i)->get_data_type() != second_part_keys.at(i)->get_data_type() ||
first_part_keys.at(i)->get_collation_type() != second_part_keys.at(i)->get_collation_type()) {
is_compatible = false;
} else { /*do nothing*/ }
}
}
return ret;
}
int ObShardingInfo::is_join_key_cover_partition_key(const EqualSets &equal_sets,
const ObIArray<ObRawExpr *> &first_keys,
const ObIArray<ObShardingInfo *> &first_shardings,
const ObIArray<ObRawExpr *> &second_keys,
const ObIArray<ObShardingInfo *> &second_shardings,
bool &is_cover)
{
int ret = OB_SUCCESS;
ObSEArray<ObSEArray<ObRawExpr*, 8>, 8> first_part_keys;
ObSEArray<ObSEArray<ObRawExpr*, 8>, 8> second_part_keys;
is_cover = false;
bool is_compatible = false;
ObShardingInfo *first_left_sharding = NULL;
if (OB_UNLIKELY(first_keys.count() != second_keys.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected array count", K(first_keys.count()), K(second_keys.count()), K(ret));
} else if (OB_FAIL(extract_partition_key(first_shardings,
first_part_keys))) {
LOG_WARN("failed to extract partition keys", K(ret));
} else if (OB_FAIL(extract_partition_key(second_shardings,
second_part_keys))) {
LOG_WARN("failed to extract partition keys", K(ret));
} else if (!first_shardings.empty() && OB_ISNULL(first_left_sharding = first_shardings.at(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(first_shardings), K(ret));
} else if (OB_FAIL(is_compatible_partition_key(first_left_sharding,
first_part_keys,
second_part_keys,
is_compatible))) {
LOG_WARN("failed to check if is comptiable keys", K(ret));
} else if (!is_compatible) {
/* do nothing */
} else {
is_cover = true;
for (int64_t i = 0; OB_SUCC(ret) && is_cover && i < first_part_keys.count(); i++) {
bool is_equal = false;
for(int64_t j = 0; OB_SUCC(ret) && !is_equal && j < first_keys.count(); j++) {
if (OB_FAIL(is_expr_equivalent(equal_sets,
*first_left_sharding,
first_part_keys.at(i),
second_part_keys.at(i),
first_keys.at(j),
second_keys.at(j),
is_equal))) {
LOG_WARN("failed to check expr equivalent", K(ret));
} else { /*do nothing*/ }
}
if (OB_SUCC(ret) && !is_equal) {
is_cover = false;
}
}
}
return ret;
}
int ObShardingInfo::is_lossless_column_cast(const ObRawExpr *expr,
const ObShardingInfo &sharding_info, bool &is_lossless)
{
int ret = OB_SUCCESS;
is_lossless = false;
if (OB_ISNULL(expr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected null raw expr", K(ret));
} else if (OB_FAIL(ObOptimizerUtil::is_lossless_column_cast(expr, is_lossless))) {
LOG_WARN("check lossless column cast failed", K(ret));
} else if (is_lossless) {
if (expr->get_result_type().is_decimal_int()
&& expr->get_param_expr(0)->get_result_type().is_decimal_int()
&& is_part_func_scale_sensitive(sharding_info, ObDecimalIntType)) {
is_lossless = (expr->get_scale() == expr->get_param_expr(0)->get_scale());
}
}
LOG_DEBUG("sharding info, is_lossless column_cast", K(*expr), K(is_lossless), K(sharding_info));
return ret;
}
int ObShardingInfo::is_expr_equivalent(const EqualSets &equal_sets,
const ObShardingInfo &first_sharding,
const ObIArray<ObRawExpr*> &first_part_keys,
const ObIArray<ObRawExpr*> &second_part_keys,
ObRawExpr *first_key,
ObRawExpr *second_key,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = false;
bool first_key_lossless = false, second_key_lossless = false;
if (OB_ISNULL(first_key) || OB_ISNULL(second_key)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(first_key), K(second_key), K(ret));
} else if (OB_FAIL(is_lossless_column_cast(first_key, first_sharding, first_key_lossless))) {
LOG_WARN("check lossless cast failed", K(ret));
} else if (OB_FAIL(is_lossless_column_cast(second_key, first_sharding, second_key_lossless))) {
LOG_WARN("check lossless cast failed", K(ret));
} else {
if (first_key_lossless) {
first_key = first_key->get_param_expr(0);
}
if (second_key_lossless) {
second_key = second_key->get_param_expr(0);
}
}
if (OB_FAIL(ret)) {
// do nothing
} else {
bool left_is_equal = false;
bool right_is_equal = false;
for (int64_t i = 0; OB_SUCC(ret) && !left_is_equal && i < first_part_keys.count(); i++) {
if (OB_ISNULL(first_part_keys.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (ObOptimizerUtil::is_expr_equivalent(first_part_keys.at(i), first_key, equal_sets)) {
left_is_equal = true;
} else { /*do nothing*/ }
}
for (int64_t i = 0; OB_SUCC(ret) && !right_is_equal && i < second_part_keys.count(); i++) {
if (OB_ISNULL(second_part_keys.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (ObOptimizerUtil::is_expr_equivalent(second_part_keys.at(i), second_key, equal_sets)) {
right_is_equal = true;
} else { /*do nothing*/ }
}
if (OB_SUCC(ret)) {
is_equal = left_is_equal && right_is_equal;
}
}
return ret;
}
bool ObShardingInfo::is_part_func_scale_sensitive(
const sql::ObShardingInfo &sharding_info, const common::ObObjType obj_type)
{
bool ret = false;
ObPartitionFuncType part_func_type = PARTITION_FUNC_TYPE_MAX;
if (sharding_info.get_part_level() == PARTITION_LEVEL_ONE) {
part_func_type = sharding_info.get_part_func_type();
} else if (sharding_info.get_part_level() == PARTITION_LEVEL_TWO) {
part_func_type = sharding_info.get_sub_part_func_type();
}
// PARTITION_FUNC_TYPE_MAX need to be scale sensitive. Consider PWJ:
//
// Hash Join(equal_conds([cast(c.deptno, DECIMAL_INT(5, 2)) = p.c1]))
// EXCHANGE HASH(#key = deptno)
// SUB_PLAN0
// EXCHANGE HASH(#key = c1)
// SUB_PLAN1
//
// It's a extended partition wise join, part_func_type is PARTITION_FUNC_TYPE_MAX.
// Partitions hashed by `deptno` must be same with partitions hashed by `cast(c.deptno, DECIMAL_INT(5, 2))`
if (PARTITION_FUNC_TYPE_HASH == part_func_type || PARTITION_FUNC_TYPE_KEY == part_func_type
|| PARTITION_FUNC_TYPE_KEY_IMPLICIT == part_func_type
|| PARTITION_FUNC_TYPE_MAX == part_func_type) {
ret = ob_is_decimal_int(obj_type);
}
return ret;
}
int ObShardingInfo::extract_partition_key(const ObIArray<ObShardingInfo *> &input_shardings,
ObIArray<ObSEArray<ObRawExpr*, 8>> &partition_key_list)
{
int ret = OB_SUCCESS;
int64_t partition_cnt = 0;
ObSEArray<ObRawExpr*, 8> partition_keys;
for (int64_t i = 0; OB_SUCC(ret) && i < input_shardings.count(); i++) {
partition_keys.reuse();
if (OB_ISNULL(input_shardings.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(input_shardings.at(i)->get_all_partition_keys(partition_keys, true))) {
LOG_WARN("failed to get partition keys", K(ret));
} else if (partition_keys.empty()) {
/* do nothing */
} else if (0 == partition_cnt) {
partition_cnt = partition_keys.count();
ObSEArray<ObRawExpr*, 8> temp_keys;
for (int64_t j = 0; OB_SUCC(ret) && j < partition_cnt; j++) {
temp_keys.reuse();
if (OB_FAIL(temp_keys.push_back(partition_keys.at(j)))) {
LOG_WARN("failed to push back expr", K(ret));
} else if (OB_FAIL(partition_key_list.push_back(temp_keys))) {
LOG_WARN("failed to push back expr array", K(ret));
} else { /*do nothing*/ }
}
} else if (OB_UNLIKELY(partition_cnt != partition_keys.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected array cnt", K(partition_cnt), K(partition_keys.count()), K(ret));
} else {
for (int64_t j = 0; OB_SUCC(ret) && j < partition_cnt; j++) {
if (OB_FAIL(partition_key_list.at(j).push_back(partition_keys.at(j)))) {
LOG_WARN("failed to push back expr", K(ret));
} else { /*do nothing*/ }
}
}
}
return ret;
}
int ObShardingInfo::check_if_match_partition_wise(const EqualSets &equal_sets,
const common::ObIArray<ObRawExpr*> &left_keys,
const common::ObIArray<ObRawExpr*> &right_keys,
ObShardingInfo *left_strong_sharding,
ObShardingInfo *right_strong_sharding,
bool &is_partition_wise)
{
int ret = OB_SUCCESS;
ObSEArray<ObShardingInfo*, 1> dummy_sharding;
ObSEArray<bool, 4> null_safe_info;
for (int64_t i = 0; OB_SUCC(ret) && i < left_keys.count(); i++) {
if (OB_FAIL(null_safe_info.push_back(true))) {
LOG_WARN("failed to push back null safe info", K(ret));
} else { /*do nothing*/ }
}
if (OB_SUCC(ret)) {
if (OB_FAIL(check_if_match_partition_wise(equal_sets,
left_keys,
right_keys,
null_safe_info,
left_strong_sharding,
dummy_sharding,
right_strong_sharding,
dummy_sharding,
is_partition_wise))) {
LOG_WARN("failed to check if match partition wise", K(ret));
} else {
LOG_TRACE("succeed to check if match partition wise", K(is_partition_wise));
}
}
return ret;
}
int ObShardingInfo::check_if_match_extended_partition_wise(const EqualSets &equal_sets,
ObIArray<ObAddr> &left_server_list,
ObIArray<ObAddr> &right_server_list,
const common::ObIArray<ObRawExpr*> &left_keys,
const common::ObIArray<ObRawExpr*> &right_keys,
ObShardingInfo *left_strong_sharding,
ObShardingInfo *right_strong_sharding,
bool &is_ext_partition_wise)
{
int ret = OB_SUCCESS;
ObSEArray<ObShardingInfo*, 1> dummy_sharding;
ObSEArray<bool, 4> null_safe_info;
for (int64_t i = 0; OB_SUCC(ret) && i < left_keys.count(); i++) {
if (OB_FAIL(null_safe_info.push_back(true))) {
LOG_WARN("failed to push back null safe info", K(ret));
} else { /*do nothing*/ }
}
if (OB_SUCC(ret)) {
if (OB_FAIL(check_if_match_extended_partition_wise(equal_sets,
left_server_list,
right_server_list,
left_keys,
right_keys,
null_safe_info,
left_strong_sharding,
dummy_sharding,
right_strong_sharding,
dummy_sharding,
is_ext_partition_wise))) {
LOG_WARN("failed to check if match extended partition wise", K(ret));
} else {
LOG_TRACE("succeed to check if match extended partition wise", K(is_ext_partition_wise));
}
}
return ret;
}
int ObShardingInfo::check_if_match_partition_wise(const EqualSets &equal_sets,
const common::ObIArray<ObRawExpr*> &left_keys,
const common::ObIArray<ObRawExpr*> &right_keys,
const common::ObIArray<bool> &null_safe_info,
ObShardingInfo *left_strong_sharding,
const common::ObIArray<ObShardingInfo *> &left_weak_sharding,
ObShardingInfo *right_strong_sharding,
const common::ObIArray<ObShardingInfo *> &right_weak_sharding,
bool &is_partition_wise)
{
int ret = OB_SUCCESS;
is_partition_wise = false;
if (OB_UNLIKELY(left_keys.count() != null_safe_info.count()) ||
OB_UNLIKELY(right_keys.count() != null_safe_info.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected array count", K(left_keys.count()), K(right_keys.count()),
K(null_safe_info.count()), K(ret));
} else {
bool has_null_safe = false;
ObSEArray<ObShardingInfo*, 8> left_sharding;
ObSEArray<ObShardingInfo*, 8> right_sharding;
ObSEArray<ObRawExpr*, 8> strong_left_keys;
ObSEArray<ObRawExpr*, 8> strong_right_keys;
for (int64_t i = 0; OB_SUCC(ret) && i < null_safe_info.count(); i++) {
if (OB_ISNULL(left_keys.at(i)) || OB_ISNULL(right_keys.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(left_keys.at(i)), K(right_keys.at(i)), K(ret));
} else if (null_safe_info.at(i)) {
has_null_safe = true;
} else if (OB_FAIL(strong_left_keys.push_back(left_keys.at(i))) ||
OB_FAIL(strong_right_keys.push_back(right_keys.at(i)))) {
LOG_WARN("failed to push back keys", K(ret));
} else { /*do nothing*/ }
}
if (OB_SUCC(ret)) {
if (NULL != left_strong_sharding &&
NULL != left_strong_sharding->get_phy_table_location_info() &&
OB_FAIL(left_sharding.push_back(left_strong_sharding))) {
LOG_WARN("failed to push back sharding info", K(ret));
} else if (NULL != right_strong_sharding &&
NULL != right_strong_sharding->get_phy_table_location_info() &&
OB_FAIL(right_sharding.push_back(right_strong_sharding))) {
LOG_WARN("failed to push back sharding info", K(ret));
} else if (has_null_safe &&
OB_FAIL(check_if_match_partition_wise(equal_sets,
left_keys,
right_keys,
left_sharding,
right_sharding,
is_partition_wise))) {
LOG_WARN("failed to check if match partition wise join", K(ret));
} else if (is_partition_wise) {
LOG_TRACE("succeed to check if match partition wise join", K(is_partition_wise));
} else if (OB_FAIL(append(left_sharding, left_weak_sharding)) ||
OB_FAIL(append(right_sharding, right_weak_sharding))) {
LOG_WARN("failed to append sharding info", K(ret));
} else if (OB_FAIL(check_if_match_partition_wise(equal_sets,
strong_left_keys,
strong_right_keys,
left_sharding,
right_sharding,
is_partition_wise))) {
LOG_WARN("failed to check if match partition wise join", K(ret));
} else {
LOG_TRACE("succeed to check if match partition wise join", K(is_partition_wise));
}
}
}
return ret;
}
int ObShardingInfo::check_if_match_extended_partition_wise(const EqualSets &equal_sets,
ObIArray<ObAddr> &left_server_list,
ObIArray<ObAddr> &right_server_list,
const common::ObIArray<ObRawExpr*> &left_keys,
const common::ObIArray<ObRawExpr*> &right_keys,
const common::ObIArray<bool> &null_safe_info,
ObShardingInfo *left_strong_sharding,
const common::ObIArray<ObShardingInfo *> &left_weak_sharding,
ObShardingInfo *right_strong_sharding,
const common::ObIArray<ObShardingInfo *> &right_weak_sharding,
bool &is_ext_partition_wise)
{
int ret = OB_SUCCESS;
is_ext_partition_wise = false;
if (OB_UNLIKELY(left_keys.count() != null_safe_info.count()) ||
OB_UNLIKELY(right_keys.count() != null_safe_info.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected array count", K(left_keys.count()), K(right_keys.count()),
K(null_safe_info.count()), K(ret));
} else {
bool has_null_safe = false;
ObSEArray<ObShardingInfo*, 8> left_sharding;
ObSEArray<ObShardingInfo*, 8> right_sharding;
ObSEArray<ObRawExpr*, 8> strong_left_keys;
ObSEArray<ObRawExpr*, 8> strong_right_keys;
for (int64_t i = 0; OB_SUCC(ret) && i < null_safe_info.count(); i++) {
if (OB_ISNULL(left_keys.at(i)) || OB_ISNULL(right_keys.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(left_keys.at(i)), K(right_keys.at(i)), K(ret));
} else if (null_safe_info.at(i)) {
has_null_safe = true;
} else if (OB_FAIL(strong_left_keys.push_back(left_keys.at(i))) ||
OB_FAIL(strong_right_keys.push_back(right_keys.at(i)))) {
LOG_WARN("failed to push back keys", K(ret));
} else { /*do nothing*/ }
}
if (OB_SUCC(ret)) {
if (NULL != left_strong_sharding &&
left_strong_sharding->is_distributed_without_table_location_with_partitioning() &&
OB_FAIL(left_sharding.push_back(left_strong_sharding))) {
LOG_WARN("failed to push back sharding info", K(ret));
} else if (NULL != right_strong_sharding &&
right_strong_sharding->is_distributed_without_table_location_with_partitioning() &&
OB_FAIL(right_sharding.push_back(right_strong_sharding))) {
LOG_WARN("failed to push back sharding info", K(ret));
} else if (has_null_safe &&
OB_FAIL(check_if_match_extended_partition_wise(equal_sets,
left_server_list,
right_server_list,
left_keys,
right_keys,
left_sharding,
right_sharding,
is_ext_partition_wise))) {
LOG_WARN("failed to check if match extended partition wise join", K(ret));
} else if (is_ext_partition_wise) {
LOG_TRACE("succeed to check if match extended partition wise join", K(is_ext_partition_wise));
} else if (OB_FAIL(append(left_sharding, left_weak_sharding)) ||
OB_FAIL(append(right_sharding, right_weak_sharding))) {
LOG_WARN("failed to append sharding info", K(ret));
} else if (OB_FAIL(check_if_match_extended_partition_wise(equal_sets,
left_server_list,
right_server_list,
strong_left_keys,
strong_right_keys,
left_sharding,
right_sharding,
is_ext_partition_wise))) {
LOG_WARN("failed to check if match extended partition wise join", K(ret));
} else {
LOG_TRACE("succeed to check if match extended partition wise join", K(is_ext_partition_wise));
}
}
}
return ret;
}
int ObShardingInfo::check_if_match_partition_wise(const EqualSets &equal_sets,
const common::ObIArray<ObRawExpr*> &left_keys,
const common::ObIArray<ObRawExpr*> &right_keys,
const common::ObIArray<ObShardingInfo *> &left_sharding,
const common::ObIArray<ObShardingInfo *> &right_sharding,
bool &is_partition_wise)
{
int ret = OB_SUCCESS;
bool is_key_covered = false;
ObShardingInfo *first_left_sharding = NULL;
ObShardingInfo *first_right_sharding = NULL;
is_partition_wise = false;
if (left_keys.empty() || right_keys.empty() || left_sharding.empty() || right_sharding.empty()) {
is_partition_wise = false;
} else if (OB_ISNULL(first_left_sharding = left_sharding.at(0)) ||
OB_ISNULL(first_right_sharding = right_sharding.at(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(first_left_sharding), K(first_right_sharding), K(ret));
} else if (!first_left_sharding->is_distributed() || !first_right_sharding->is_distributed()) {
is_partition_wise = false;
} else if (first_left_sharding->part_level_ != first_right_sharding->part_level_ ||
first_left_sharding->is_partition_single_ != first_right_sharding->is_partition_single_ ||
first_left_sharding->is_subpartition_sinlge_ != first_right_sharding->is_subpartition_sinlge_) {
is_partition_wise = false;
} else if (OB_FAIL(is_join_key_cover_partition_key(equal_sets,
left_keys,
left_sharding,
right_keys,
right_sharding,
is_key_covered))) {
LOG_WARN("failed to check is join key cover partition key", K(ret));
} else if (!is_key_covered) {
/*do nothing*/
} else {
bool is_equal = false;
PwjTable l_table;
PwjTable r_table;
SMART_VAR(ObStrictPwjComparer, pwj_comparer) {
if (OB_FAIL(l_table.init(*first_left_sharding))) {
LOG_WARN("failed to init pwj table with sharding info", K(ret));
} else if (OB_FAIL(r_table.init(*first_right_sharding))) {
LOG_WARN("failed to init pwj table with sharding info", K(ret));
} else if (OB_FAIL(pwj_comparer.add_table(l_table, is_equal))) {
LOG_WARN("failed to add table", K(ret));
} else if (!is_equal) {
// do nothing
} else if (OB_FAIL(pwj_comparer.add_table(r_table, is_equal))) {
LOG_WARN("failed to add table", K(ret));
} else if (is_equal){
is_partition_wise = true;
}
}
}
LOG_TRACE("succeed check if match partition wise",
K(left_sharding), K(right_sharding), K(is_partition_wise), K(is_key_covered));
return ret;
}
int ObShardingInfo::check_if_match_extended_partition_wise(const EqualSets &equal_sets,
ObIArray<ObAddr> &left_server_list,
ObIArray<ObAddr> &right_server_list,
const common::ObIArray<ObRawExpr*> &left_keys,
const common::ObIArray<ObRawExpr*> &right_keys,
const common::ObIArray<ObShardingInfo *> &left_sharding,
const common::ObIArray<ObShardingInfo *> &right_sharding,
bool &is_ext_partition_wise)
{
int ret = OB_SUCCESS;
bool is_key_covered = false;
ObShardingInfo *first_left_sharding = NULL;
ObShardingInfo *first_right_sharding = NULL;
is_ext_partition_wise = false;
if (left_keys.empty() || right_keys.empty() || left_sharding.empty() || right_sharding.empty()) {
is_ext_partition_wise = false;
} else if (OB_ISNULL(first_left_sharding = left_sharding.at(0)) ||
OB_ISNULL(first_right_sharding = right_sharding.at(0))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(first_left_sharding), K(first_right_sharding), K(ret));
} else if (!first_left_sharding->is_distributed() || !first_right_sharding->is_distributed()) {
is_ext_partition_wise = false;
} else if (!first_left_sharding->is_distributed_without_table_location_with_partitioning() ||
!first_right_sharding->is_distributed_without_table_location_with_partitioning()) {
is_ext_partition_wise = false;
} else if (OB_FAIL(is_join_key_cover_partition_key(equal_sets,
left_keys,
left_sharding,
right_keys,
right_sharding,
is_key_covered))) {
LOG_WARN("failed to check is join key cover partition key", K(ret));
} else if (!is_key_covered) {
/*do nothing*/
} else {
bool is_equal = false;
PwjTable l_table;
PwjTable r_table;
ObNonStrictPwjComparer pwj_comparer;
if (OB_FAIL(l_table.init(left_server_list))) {
LOG_WARN("failed to init pwj table with sharding info", K(ret));
} else if (OB_FAIL(r_table.init(right_server_list))) {
LOG_WARN("failed to init pwj table with sharding info", K(ret));
} else if (OB_FAIL(pwj_comparer.add_table(l_table, is_equal))) {
LOG_WARN("failed to add table", K(ret));
} else if (!is_equal) {
// do nothing
} else if (OB_FAIL(pwj_comparer.add_table(r_table, is_equal))) {
LOG_WARN("failed to add table", K(ret));
} else if (is_equal) {
is_ext_partition_wise = true;
}
}
LOG_TRACE("succeed check if match extended partition wise",
K(left_sharding), K(right_sharding), K(is_ext_partition_wise));
return ret;
}
int ObShardingInfo::check_if_match_repart_or_rehash(const EqualSets &equal_sets,
const ObIArray<ObRawExpr *> &src_keys,
const ObIArray<ObRawExpr *> &target_keys,
const ObIArray<ObRawExpr *> &target_part_keys,
bool &is_match_join_keys)
{
int ret = OB_SUCCESS;
is_match_join_keys = false;
if (OB_UNLIKELY(src_keys.count() != target_keys.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected array count", K(src_keys.count()),
K(target_keys.count()), K(ret));
} else if (0 == target_part_keys.count()) {
is_match_join_keys = false;
} else {
is_match_join_keys = true;
for (int64_t i = 0; OB_SUCC(ret) && is_match_join_keys && i < target_part_keys.count(); ++i) {
ObRawExpr* right_part_key = NULL;
if (OB_ISNULL(right_part_key = target_part_keys.at(i))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(right_part_key), K(ret));
} else {
bool is_found = false;
for (int64_t j = 0; OB_SUCC(ret) && !is_found && j < target_keys.count(); ++j) {
ObRawExpr* left_key = NULL;
ObRawExpr* right_key = NULL;
if (OB_ISNULL(left_key = src_keys.at(j)) ||
OB_ISNULL(right_key = target_keys.at(j))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(left_key), K(right_key), K(ret));
} else if (ObOptimizerUtil::is_expr_equivalent(right_part_key, right_key, equal_sets)
&& right_part_key->get_result_type().get_type_class()
== left_key->get_result_type().get_type_class()
&& right_part_key->get_result_type().get_collation_type()
== left_key->get_result_type().get_collation_type()
&& !ObObjCmpFuncs::is_otimestamp_cmp(right_part_key->get_result_type().get_type(),
left_key->get_result_type().get_type())
&& !ObObjCmpFuncs::is_datetime_timestamp_cmp(
right_part_key->get_result_type().get_type(),
left_key->get_result_type().get_type())) {
is_found = true;
} else { /*do nothing*/ }
}
if (OB_SUCC(ret) && !is_found) {
is_match_join_keys = false;
}
}
}
}
return ret;
}
int ObShardingInfo::is_physically_equal_serverlist(ObIArray<ObAddr> &left_server_list,
ObIArray<ObAddr> &right_server_list,
bool &is_equal_serverlist)
{
int ret = OB_SUCCESS;
is_equal_serverlist = false;
if (left_server_list.empty() || right_server_list.empty()) {
// do nothing
} else if (left_server_list.count() != right_server_list.count()) {
// do nothing
} else if (is_shuffled_server_list(left_server_list) ||
is_shuffled_server_list(right_server_list)) {
// do nothing
} else {
is_equal_serverlist = true;
std::sort(&left_server_list.at(0), &left_server_list.at(0) + left_server_list.count());
std::sort(&right_server_list.at(0), &right_server_list.at(0) + right_server_list.count());
for (int64_t i = 0; OB_SUCC(ret) && is_equal_serverlist && i < left_server_list.count(); i ++) {
if (left_server_list.at(i) != right_server_list.at(i)) {
is_equal_serverlist = false;
}
}
}
return ret;
}
int ObShardingInfo::is_physically_both_shuffled_serverlist(ObIArray<ObAddr> &left_server_list,
ObIArray<ObAddr> &right_server_list,
bool &is_both_shuffled_serverlist)
{
int ret = OB_SUCCESS;
is_both_shuffled_serverlist = false;
if (left_server_list.empty() || right_server_list.empty()) {
// do nothing
} else if (left_server_list.count() != right_server_list.count()) {
// do nothing
} else if (is_shuffled_server_list(left_server_list) &&
is_shuffled_server_list(right_server_list)) {
// mark as non-strict pw for shuffle case
is_both_shuffled_serverlist = true;
} else {
// do nothing
}
return ret;
}
bool ObShardingInfo::is_shuffled_server_list(const ObIArray<ObAddr> &server_list)
{
return server_list.count() == 1 && is_shuffled_addr(server_list.at(0));
}
int ObShardingInfo::copy_with_part_keys(const ObShardingInfo &other)
{
int ret = OB_SUCCESS;
if (OB_FAIL(copy_without_part_keys(other))) {
} else if (OB_FAIL(partition_keys_.assign(other.get_partition_keys()))) {
LOG_WARN("failed to append partition key", K(ret));
} else if (OB_FAIL(sub_partition_keys_.assign(other.get_sub_partition_keys()))) {
LOG_WARN("failed to append sub partition key", K(ret));
} else if (OB_FAIL(part_func_exprs_.assign(other.get_partition_func()))) {
LOG_WARN("Failed to append partition function", K(ret));
} else {/*do nothing*/}
return ret;
}
int ObShardingInfo::copy_without_part_keys(const ObShardingInfo &other)
{
int ret = OB_SUCCESS;
part_level_ = other.part_level_;
part_func_type_ = other.part_func_type_;
subpart_func_type_ = other.subpart_func_type_;
part_num_ = other.part_num_;
location_type_ = other.location_type_;
phy_table_location_info_ = other.phy_table_location_info_;
partition_array_ = other.partition_array_;
can_reselect_replica_ = other.can_reselect_replica_;
is_partition_single_ = other.is_partition_single_;
is_subpartition_sinlge_ = other.is_subpartition_sinlge_;
if (OB_FAIL(all_tablet_ids_.assign(other.all_tablet_ids_))) {
LOG_WARN("failed to assign partition ids");
} else if (OB_FAIL(all_partition_indexes_.assign(other.all_partition_indexes_))) {
LOG_WARN("failed to assign used partitions", K(ret));
} else if (OB_FAIL(all_subpartition_indexes_.assign(other.all_subpartition_indexes_))) {
LOG_WARN("failed to assign used subpartitions", K(ret));
}
return ret;
}
int ObShardingInfo::get_all_partition_keys(common::ObIArray<ObRawExpr*> &out_part_keys,
bool ignore_single_partition/* = false */) const
{
int ret = OB_SUCCESS;
if (!(ignore_single_partition && is_partition_single()) &&
OB_FAIL(out_part_keys.assign(partition_keys_))) {
LOG_WARN("failed to assign array", K(ret));
} else if (!(ignore_single_partition && is_subpartition_single()) &&
append(out_part_keys, sub_partition_keys_)) {
LOG_WARN("failed to append array", K(ret));
} else {/*do nothing*/}
return ret;
}
int ObShardingInfo::get_remote_addr(ObAddr &remote) const
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!is_remote()) || OB_ISNULL(phy_table_location_info_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(location_type_), K(phy_table_location_info_), K(ret));
} else {
share::ObLSReplicaLocation replica_loc;
const ObCandiTabletLocIArray &phy_partition_loc =
phy_table_location_info_->get_phy_part_loc_info_list();
if (OB_UNLIKELY(1 != phy_partition_loc.count())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected partition count", K(phy_partition_loc.count()), K(ret));
} else if (OB_FAIL(phy_partition_loc.at(0).get_selected_replica(replica_loc))) {
LOG_WARN("fail to get selected replica", K(ret), K(phy_partition_loc.at(0)));
} else if (!replica_loc.is_valid()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("replica location is invalid", K(ret));
} else {
remote = replica_loc.get_server();
}
}
return ret;
}
int ObShardingInfo::get_total_part_cnt(int64_t &total_part_cnt) const
{
int ret = OB_SUCCESS;
total_part_cnt = 1;
if (share::schema::PARTITION_LEVEL_ONE == part_level_) {
total_part_cnt = part_num_;
} else if (share::schema::PARTITION_LEVEL_TWO == part_level_) {
total_part_cnt = 0;
ObPartition *cur_part = NULL;
for (int64_t i = 0; OB_SUCC(ret) && i < part_num_; ++i) {
if (OB_ISNULL(cur_part = partition_array_[i])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
total_part_cnt += cur_part->get_sub_part_num();
}
}
}
return ret;
}
int ObShardingInfo::is_sharding_equal(const ObShardingInfo *left_strong_sharding,
const ObIArray<ObShardingInfo*> &left_weak_shardings,
const ObShardingInfo *right_strong_sharding,
const ObIArray<ObShardingInfo*> &right_weak_shardings,
const EqualSets &equal_sets,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = false;
if (OB_FAIL(is_sharding_equal(left_strong_sharding,
right_strong_sharding,
equal_sets,
is_equal))) {
LOG_WARN("failed to check if sharding is equal", K(ret));
} else if (!is_equal) {
/*do nothing*/
} else if (OB_FAIL(is_sharding_equal(left_weak_shardings,
right_weak_shardings,
equal_sets,
is_equal))) {
LOG_WARN("failed to check if sharding is equal", K(ret));
} else { /*do nothing*/ }
return ret;
}
int ObShardingInfo::is_sharding_equal(const ObIArray<ObShardingInfo*> &left_sharding,
const ObIArray<ObShardingInfo*> &right_sharding,
const EqualSets &equal_sets,
bool &is_equal)
{
int ret = OB_SUCCESS;
bool is_left_subset = false;
bool is_right_subset = false;
is_equal = false;
if (OB_FAIL(is_subset_sharding(left_sharding,
right_sharding,
equal_sets,
is_left_subset))) {
LOG_WARN("failed to check is subset sharding", K(ret));
} else if (OB_FAIL(is_subset_sharding(right_sharding,
left_sharding,
equal_sets,
is_right_subset))) {
LOG_WARN("failed to check is subset sharding", K(ret));
} else {
is_equal = is_left_subset && is_right_subset;
}
return ret;
}
int ObShardingInfo::is_subset_sharding(const ObIArray<ObShardingInfo*> &subset_sharding,
const ObIArray<ObShardingInfo*> &target_sharding,
const EqualSets &equal_sets,
bool &is_subset)
{
int ret = OB_SUCCESS;
is_subset = true;
for (int64_t i = 0; OB_SUCC(ret) && is_subset && i < subset_sharding.count(); i++) {
bool is_equal = false;
for (int64_t j = 0; OB_SUCC(ret) && !is_equal && j < target_sharding.count(); j++) {
if (OB_FAIL(is_sharding_equal(subset_sharding.at(i),
target_sharding.at(j),
equal_sets,
is_equal))) {
LOG_WARN("failed to check sharding is equal", K(ret));
} else { /*do nothing*/ }
}
if (OB_SUCC(ret) && !is_equal) {
is_subset = false;
}
}
return ret;
}
int ObShardingInfo::is_sharding_equal(const ObShardingInfo *left_sharding,
const ObShardingInfo *right_sharding,
const EqualSets &equal_sets,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = false;
if (left_sharding == right_sharding) {
is_equal = true;
} else if (NULL == left_sharding || NULL == right_sharding) {
is_equal = false;
} else if (left_sharding->get_location_type() != right_sharding->get_location_type()) {
is_equal = false;
} else if (left_sharding->get_can_reselect_replica() != right_sharding->get_can_reselect_replica()) {
is_equal = false;
} else if (left_sharding->is_remote() || left_sharding->get_can_reselect_replica()) {
ObSEArray<common::ObAddr, 2> left_servers;
ObSEArray<common::ObAddr, 2> right_servers;
if (OB_FAIL(get_serverlist_from_sharding(*left_sharding, left_servers))) {
LOG_WARN("failed to get server list from left sharding", K(ret));
} else if (OB_FAIL(get_serverlist_from_sharding(*right_sharding, right_servers))) {
LOG_WARN("failed to get server list from right sharding", K(ret));
} else if (OB_FAIL(is_physically_equal_serverlist(left_servers,
right_servers,
is_equal))) {
LOG_WARN("failed to check equal server list", K(ret));
} else { /*do nothing*/ }
} else if (left_sharding->is_match_all() || left_sharding->is_local()) {
is_equal = true;
} else if (!ObOptimizerUtil::same_exprs(left_sharding->get_partition_keys(),
right_sharding->get_partition_keys(),
equal_sets) ||
!ObOptimizerUtil::same_exprs(left_sharding->get_sub_partition_keys(),
right_sharding->get_sub_partition_keys(),
equal_sets) ||
!ObOptimizerUtil::same_exprs(left_sharding->get_partition_func(),
right_sharding->get_partition_func(),
equal_sets)) {
is_equal = false;
} else if (NULL == left_sharding->get_phy_table_location_info() &&
NULL == right_sharding->get_phy_table_location_info()) {
is_equal = true;
} else if (OB_FAIL(is_compatible_partition_key(*left_sharding, *right_sharding, is_equal))) {
LOG_WARN("failed to check if is comptiable keys", K(ret));
} else if (!is_equal) {
/* do nothing */
} else {
PwjTable l_table;
PwjTable r_table;
SMART_VAR(ObStrictPwjComparer, pwj_comparer) {
if (OB_FAIL(l_table.init(*left_sharding))) {
LOG_WARN("failed to init pwj table with sharding info", K(ret));
} else if (OB_FAIL(r_table.init(*right_sharding))) {
LOG_WARN("failed to init pwj table with sharding info", K(ret));
} else if (OB_FAIL(pwj_comparer.add_table(l_table, is_equal))) {
LOG_WARN("failed to add table", K(ret));
} else if (!is_equal) {
// do nothing
} else if (OB_FAIL(pwj_comparer.add_table(r_table, is_equal))) {
LOG_WARN("failed to add table", K(ret));
} else { /*do nothing*/ }
}
}
if (OB_SUCC(ret)) {
LOG_TRACE("succeed to check whether sharding info is equal", K(is_equal));
}
return ret;
}
int ObShardingInfo::get_serverlist_from_sharding(const ObShardingInfo &sharding,
ObIArray<common::ObAddr> &server_list)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(sharding.phy_table_location_info_)) {
// do nothing
} else {
const ObCandiTabletLocIArray &locations = sharding.phy_table_location_info_->get_phy_part_loc_info_list();
for (int64_t i = 0; OB_SUCC(ret) && i < locations.count(); ++i) {
share::ObLSReplicaLocation replica_loc;
if (OB_FAIL(locations.at(i).get_selected_replica(replica_loc))) {
LOG_WARN("fail to get selected replica", K(ret), K(locations.at(i)));
} else if (!replica_loc.is_valid()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("replica location is invalid", K(ret), K(i), K(replica_loc));
} else if (OB_FAIL(server_list.push_back(replica_loc.get_server()))) {
LOG_WARN("failed to push back server addr", K(ret));
}
}
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink