hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
948ac8764c01b4369f1c8026586c7017dc25f98d
oceanbase/src/sql/optimizer/ob_pwj_comparer.cpp
wjhh2008 0d6f3a8316 [FEAT MERGE] Support partitioned external table, and opt select into outfile 
Co-authored-by: SevenJ-swj <sevenjworkstation@gmail.com>
Co-authored-by: dontknow9179 <545187809@qq.com>
2024-04-16 16:15:48 +00:00

1117 lines
51 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_pwj_comparer.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_opt_est_utils.h"
#include "sql/resolver/dml/ob_dml_stmt.h"
#include "sql/resolver/expr/ob_raw_expr_util.h"
using namespace oceanbase::sql;
using namespace oceanbase::common;
using namespace oceanbase::share::schema;
const int64_t ObPwjComparer::MIN_ID_LOCATION_BUCKET_NUMBER = 100;
const int64_t ObPwjComparer::DEFAULT_ID_ID_BUCKET_NUMBER = 1000;
int PwjTable::init(const ObShardingInfo &sharding)
{
int ret = OB_SUCCESS;
phy_table_loc_info_ = sharding.get_phy_table_location_info();
part_level_ = sharding.get_part_level();
part_type_ = sharding.get_part_func_type();
subpart_type_ = sharding.get_sub_part_func_type();
partition_array_ = sharding.get_partition_array();
part_number_ = sharding.get_part_number();
is_partition_single_ = sharding.is_partition_single();
is_subpartition_single_ = sharding.is_subpartition_single();
if (OB_FAIL(ordered_tablet_ids_.assign(sharding.get_all_tablet_ids()))) {
LOG_WARN("failed to assign partition ids", K(ret));
} else if (OB_FAIL(all_partition_indexes_.assign(sharding.get_all_partition_indexes()))) {
LOG_WARN("failed to assign all partition indexes", K(ret));
} else if (OB_FAIL(all_subpartition_indexes_.assign(sharding.get_all_subpartition_indexes()))) {
LOG_WARN("failed to assign all subpartition indexes", K(ret));
}
return ret;
}
int PwjTable::init(const ObTableSchema &table_schema, const ObCandiTableLoc &phy_tbl_info)
{
int ret = OB_SUCCESS;
if (OB_FAIL(ObPwjComparer::extract_all_partition_indexes(phy_tbl_info,
table_schema,
ordered_tablet_ids_,
all_partition_indexes_,
all_subpartition_indexes_,
is_partition_single_,
is_subpartition_single_))) {
LOG_WARN("failed to extract used partition indexes", K(ret));
} else {
phy_table_loc_info_ = &phy_tbl_info;
part_level_ = table_schema.get_part_level();
part_type_ = table_schema.get_part_option().get_part_func_type();
partition_array_ = table_schema.get_part_array();
part_number_ = table_schema.get_partition_num();
if (share::schema::PARTITION_LEVEL_TWO == part_level_) {
subpart_type_ = table_schema.get_sub_part_option().get_part_func_type();
}
}
if (OB_SUCC(ret)
&& ((share::schema::PARTITION_LEVEL_TWO == part_level_) || (share::schema::PARTITION_LEVEL_ONE == part_level_))
&& 0 == part_number_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected part number", K(table_schema), K(phy_tbl_info));
}
return ret;
}
int PwjTable::init(const ObIArray<ObAddr> &server_list)
{
int ret = OB_SUCCESS;
if (OB_FAIL(server_list_.assign(server_list))) {
LOG_WARN("failed to assign server list for non-strict cons", K(ret));
}
return ret;
}
int PwjTable::assign(const PwjTable &other)
{
int ret = OB_SUCCESS;
phy_table_loc_info_ = other.phy_table_loc_info_;
part_level_ = other.part_level_;
part_type_ = other.part_type_;
subpart_type_ = other.subpart_type_;
partition_array_ = other.partition_array_;
part_number_ = other.part_number_;
is_partition_single_ = other.is_partition_single_;
is_subpartition_single_ = other.is_subpartition_single_;
if (OB_FAIL(ordered_tablet_ids_.assign(other.ordered_tablet_ids_))) {
LOG_WARN("failed to assign ordered partition indexes", K(ret));
} else if (OB_FAIL(all_partition_indexes_.assign(other.all_partition_indexes_))) {
LOG_WARN("failed to assign used partition indexes", K(ret));
} else if (OB_FAIL(all_subpartition_indexes_.assign(other.all_subpartition_indexes_))) {
LOG_WARN("failed to assign used subpartition indexes", K(ret));
} else if (OB_FAIL(server_list_.assign(other.server_list_))) {
LOG_WARN("failed to assign server list for non-strict cons", K(ret));
}
return ret;
}
void ObPwjComparer::reset()
{
pwj_tables_.reset();
}
int ObPwjComparer::add_table(PwjTable &table, bool &is_match_pwj)
{
int ret = OB_SUCCESS;
UNUSED(table);
is_match_pwj = false;
return ret;
}
int ObPwjComparer::extract_all_partition_indexes(const ObCandiTableLoc &phy_table_location_info,
const ObTableSchema &table_schema,
ObIArray<uint64_t> &all_tablet_ids,
ObIArray<int64_t> &all_partition_indexes,
ObIArray<int64_t> &all_subpartition_indexes,
bool &is_partition_single,
bool &is_subpartition_single)
{
int ret = OB_SUCCESS;
const ObCandiTabletLocIArray &phy_partitions =
phy_table_location_info.get_phy_part_loc_info_list();
ObPartitionLevel part_level = table_schema.get_part_level();
is_partition_single = false;
is_subpartition_single = false;
if (share::schema::PARTITION_LEVEL_ZERO == part_level) {
// do nothing
} else if (share::schema::PARTITION_LEVEL_ONE == part_level) {
for (int64_t i = 0; OB_SUCC(ret) && i < phy_partitions.count(); ++i) {
// 对于一级分区表part_id(一级逻辑分区id) = partition_id(物理分区id)
ObTabletID tablet_id = phy_partitions.at(i).get_partition_location().get_tablet_id();
int64_t part_index = -1;
int64_t subpart_index = -1;
if (table_schema.is_external_table()) {
if (OB_FAIL(all_tablet_ids.push_back(tablet_id.id()))) { //mock
LOG_WARN("failed to push back partition id", K(ret));
} else if (OB_FAIL(all_partition_indexes.push_back(part_index))) {
LOG_WARN("failed to push back partition index", K(ret));
}
} else if (OB_FAIL(table_schema.get_part_idx_by_tablet(tablet_id, part_index, subpart_index))) {
LOG_WARN("failed to get part idx by tablet", K(ret));
} else if (OB_FAIL(all_tablet_ids.push_back(tablet_id.id()))) {
LOG_WARN("failed to push back partition id", K(ret));
} else if (OB_FAIL(all_partition_indexes.push_back(part_index))) {
LOG_WARN("failed to push back partition index", K(ret));
}
}
} else if (share::schema::PARTITION_LEVEL_TWO == part_level) {
for (int64_t i = 0; OB_SUCC(ret) && i < phy_partitions.count(); ++i) {
int64_t partition_id = phy_partitions.at(i).get_partition_location().get_partition_id();
ObTabletID tablet_id = phy_partitions.at(i).get_partition_location().get_tablet_id();
int64_t part_index = -1;
int64_t subpart_index = -1;
if (OB_FAIL(table_schema.get_part_idx_by_tablet(tablet_id, part_index, subpart_index))) {
LOG_WARN("failed to get part idx by tablet", K(ret));
} else if (OB_FAIL(all_tablet_ids.push_back(tablet_id.id()))) {
LOG_WARN("failed to push back partition id", K(ret));
} else if (OB_FAIL(all_partition_indexes.push_back(part_index))) {
LOG_WARN("failed to push back part index", K(ret));
} else if (OB_FAIL(all_subpartition_indexes.push_back(subpart_index))) {
LOG_WARN("failed to push back subpart index");
}
}
}
if (OB_SUCC(ret) && share::schema::PARTITION_LEVEL_TWO == part_level) {
if (all_partition_indexes.count() > 0) {
// 检查是否只涉及到一个一级分区
const int64_t first_part_id = all_partition_indexes.at(0);
is_partition_single = true;
for (int64_t i = 1; i < all_partition_indexes.count(); ++i) {
if (first_part_id != all_partition_indexes.at(i)) {
is_partition_single = false;
break;
}
}
}
if (all_subpartition_indexes.count() > 0) {
// 是否每个一级分区都只涉及一个二级分区
is_subpartition_single = true;
ObSqlBitSet<> part_ids;
for (int64_t i = 0; OB_SUCC(ret) && i < all_partition_indexes.count(); ++i) {
if (part_ids.has_member(all_partition_indexes.at(i))) {
is_subpartition_single = false;
break;
} else if (OB_FAIL(part_ids.add_member(all_partition_indexes.at(i)))) {
LOG_WARN("failed to add member", K(ret));
}
}
}
}
LOG_TRACE("success extract all partition indexes",
K(phy_partitions), K(all_tablet_ids), K(all_partition_indexes),
K(all_subpartition_indexes), K(is_partition_single), K(is_subpartition_single));
return ret;
}
int ObPwjComparer::is_partition_equal(const ObPartition *l_partition,
const ObPartition *r_partition,
const bool is_range_partition,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = false;
if (OB_ISNULL(l_partition) || OB_ISNULL(r_partition)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(l_partition), K(r_partition), K(ret));
} else if (is_range_partition) {
if (OB_FAIL(is_row_equal(l_partition->get_high_bound_val(),
r_partition->get_high_bound_val(),
is_equal))) {
LOG_WARN("failed to check is row equal", K(ret));
}
} else if (OB_FAIL(is_list_partition_equal(l_partition, r_partition, is_equal))) {
LOG_WARN("failed to check is list partition equal", K(ret));
}
return ret;
}
int ObPwjComparer::is_subpartition_equal(const ObSubPartition *l_subpartition,
const ObSubPartition *r_subpartition,
const bool is_range_partition,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = false;
if (OB_ISNULL(l_subpartition) || OB_ISNULL(r_subpartition)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(l_subpartition), K(r_subpartition), K(ret));
} else if (is_range_partition) {
if (OB_FAIL(is_row_equal(l_subpartition->get_high_bound_val(),
r_subpartition->get_high_bound_val(),
is_equal))) {
LOG_WARN("failed to check is row equal", K(ret));
}
} else if (OB_FAIL(is_list_partition_equal(l_subpartition, r_subpartition, is_equal))) {
LOG_WARN("failed to check is list partition equal", K(ret));
}
return ret;
}
int ObPwjComparer::is_row_equal(const ObRowkey &first_row,
const ObRowkey &second_row,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = false;
if (OB_ISNULL(first_row.get_obj_ptr()) || OB_ISNULL(second_row.get_obj_ptr())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(first_row.get_obj_ptr()),
K(second_row.get_obj_ptr()), K(ret));
} else if (first_row.get_obj_cnt() != second_row.get_obj_cnt()) {
is_equal = false;
} else {
is_equal = true;
for (int i = 0; OB_SUCC(ret) && is_equal && i < first_row.get_obj_cnt(); i++) {
if (OB_FAIL(is_obj_equal(first_row.get_obj_ptr()[i],
second_row.get_obj_ptr()[i],
is_equal))) {
LOG_WARN("failed to check obj equal", K(ret));
} else { /*do nothing*/ }
}
}
return ret;
}
int ObPwjComparer::is_list_partition_equal(const ObBasePartition *first_part,
const ObBasePartition *second_part,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = false;
if (OB_ISNULL(first_part) || OB_ISNULL(second_part)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("null part expr", K(first_part), K(second_part), K(ret));
} else if (first_part->get_list_row_values().count() != second_part->get_list_row_values().count()) {
is_equal = false;
} else {
is_equal = true;
const ObIArray<ObNewRow> &first_values = first_part->get_list_row_values();
const ObIArray<ObNewRow> &second_values = second_part->get_list_row_values();
for (int64_t i = 0; OB_SUCC(ret) && is_equal && i < first_values.count(); i++) {
bool is_find = false;
for (int64_t j = 0; OB_SUCC(ret) && !is_find && j < second_values.count(); j++) {
if (OB_FAIL(is_row_equal(first_values.at(i), second_values.at(j), is_find))) {
LOG_WARN("failed to check row equal", K(ret));
} else { /*do nothing*/ }
}
if (OB_SUCC(ret) && !is_find) {
is_equal = false;
}
}
}
return ret;
}
int ObPwjComparer::is_row_equal(const common::ObNewRow &first_row,
const common::ObNewRow &second_row,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = false;
if (OB_ISNULL(first_row.cells_) || OB_ISNULL(second_row.cells_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("null cells", K(first_row.cells_), K(second_row.cells_), K(ret));
} else if (first_row.count_ != second_row.count_) {
is_equal = false;
} else {
is_equal = true;
for (int64_t i = 0; OB_SUCC(ret) && is_equal && i < first_row.count_; i++) {
if (OB_FAIL(is_obj_equal(first_row.cells_[i], second_row.cells_[i], is_equal))) {
LOG_WARN("failed to check obj equal", K(ret));
} else { /*do nothing*/ }
}
}
return ret;
}
int ObPwjComparer::is_obj_equal(const common::ObObj &first_value,
const common::ObObj &second_value,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = false;
if (first_value.is_null() || second_value.is_null()) {
is_equal = false;
} else if (first_value.is_min_value() || second_value.is_min_value()) {
is_equal = (first_value.is_min_value() && second_value.is_min_value());
} else if (first_value.is_max_value() || second_value.is_max_value()) {
is_equal = (first_value.is_max_value() && second_value.is_max_value());
} else if (OB_UNLIKELY(first_value.get_meta() != second_value.get_meta())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("first value and second value meta not same", K(ret),
K(first_value.get_meta()), K(second_value.get_meta()));
} else {
is_equal = (first_value == second_value);
}
return ret;
}
ObStrictPwjComparer::ObStrictPwjComparer()
: ObPwjComparer(true),
part_tablet_id_map_(),
part_index_map_(),
subpart_tablet_id_map_(),
phy_part_map_(),
tablet_id_group_()
{
int ret = OB_SUCCESS;
if (OB_FAIL(phy_part_map_.create(DEFAULT_ID_ID_BUCKET_NUMBER, "SqlPwjCompare"))) {
BACKTRACE(ERROR, true, "failed to create hash map");
}
}
ObStrictPwjComparer::~ObStrictPwjComparer()
{
phy_part_map_.destroy();
}
void ObStrictPwjComparer::reset()
{
ObPwjComparer::reset();
tablet_id_group_.reset();
}
int ObStrictPwjComparer::add_table(PwjTable &table, bool &is_match_pwj)
{
int ret = OB_SUCCESS;
is_match_pwj = true;
if (OB_ISNULL(table.phy_table_loc_info_)) {
// sharding to check partition wise join maybe reset
is_match_pwj = false;
LOG_TRACE("sharding to check partition wise is invalid", K(table));
} else if (OB_FAIL(pwj_tables_.push_back(table))) {
LOG_WARN("failed to push back pwj table", K(ret));
} else if (pwj_tables_.count() <= 1) {
TabletIdArray *part_array = NULL;
// init first partition id group
if (OB_ISNULL(part_array = tablet_id_group_.alloc_place_holder())){
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to alloc place holder", K(ret));
} else if (OB_FAIL(part_array->assign(table.ordered_tablet_ids_))) {
LOG_WARN("failed to assign ordered partition ids", K(ret));
}
} else if (OB_FAIL(check_logical_equal_and_calc_match_map(pwj_tables_.at(0),
pwj_tables_.at(pwj_tables_.count() - 1),
is_match_pwj))) {
LOG_WARN("failed to calc match map", K(ret));
} else if (!is_match_pwj) {
// do nothing
} else if (OB_FAIL(is_physically_equal_partitioned(pwj_tables_.at(0),
pwj_tables_.at(pwj_tables_.count() - 1),
is_match_pwj))) {
LOG_WARN("failed to check is physically equal partitioned", K(ret));
}
return ret;
}
int ObStrictPwjComparer::is_physically_equal_partitioned(const PwjTable &l_table,
const PwjTable &r_table,
bool &is_physical_equal)
{
int ret = OB_SUCCESS;
is_physical_equal = true;
const ObCandiTabletLocIArray &left_locations =
l_table.phy_table_loc_info_->get_phy_part_loc_info_list();
const ObCandiTabletLocIArray &right_locations =
r_table.phy_table_loc_info_->get_phy_part_loc_info_list();
TabletIdArray *r_array = NULL;
if (l_table.ordered_tablet_ids_.count() != left_locations.count()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected partition count", K(ret),
K(l_table.ordered_tablet_ids_.count()), K(left_locations.count()));
} else if (left_locations.count() != right_locations.count()) {
is_physical_equal = false;
} else if (OB_ISNULL(r_array = tablet_id_group_.alloc_place_holder())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to alloc place holder", K(ret));
} else if (OB_FAIL(r_array->prepare_allocate(left_locations.count()))) {
LOG_WARN("failed to prepare allocate", K(ret));
} else {
TabletIdLocationMap l_tablet_id_map;
TabletIdLocationMap r_tablet_id_map;
const int64_t N = left_locations.count();
if (OB_FAIL(l_tablet_id_map.create(std::max(N, MIN_ID_LOCATION_BUCKET_NUMBER),
"SqlPwjCompare"))) {
LOG_WARN("failed to create hash map", K(ret));
} else if (OB_FAIL(r_tablet_id_map.create(std::max(N, MIN_ID_LOCATION_BUCKET_NUMBER),
"SqlPwjCompare"))) {
LOG_WARN("failed to create hash map", K(ret));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
const ObCandiTabletLoc &left_location = left_locations.at(i);
const ObCandiTabletLoc &right_locaiton = right_locations.at(i);
if (OB_FAIL(l_tablet_id_map.set_refactored(
left_location.get_partition_location().get_tablet_id().id(), &left_location)) ||
OB_FAIL(r_tablet_id_map.set_refactored(
right_locaiton.get_partition_location().get_tablet_id().id(), &right_locaiton))) {
LOG_WARN("failed to set refactored", K(ret));
}
}
for (int64_t i = 0; OB_SUCC(ret) && is_physical_equal && i < N; ++i) {
uint64_t l_tablet_id = l_table.ordered_tablet_ids_.at(i);
uint64_t r_tablet_id = 0;
share::ObLSReplicaLocation l_replica_loc;
share::ObLSReplicaLocation r_replica_loc;
const ObCandiTabletLoc *left_location = NULL;
const ObCandiTabletLoc *right_location = NULL;
if (OB_FAIL(phy_part_map_.get_refactored(l_tablet_id, r_tablet_id))) {
LOG_WARN("failed to get refactored", K(ret));
} else if (OB_FAIL(l_tablet_id_map.get_refactored(l_tablet_id, left_location)) ||
OB_FAIL(r_tablet_id_map.get_refactored(r_tablet_id, right_location))) {
LOG_WARN("failed to get refactored", K(ret));
} else if (OB_FAIL(left_location->get_selected_replica(l_replica_loc))) {
LOG_WARN("failed to get selected replica", K(ret), K(left_location));
} else if (OB_FAIL(right_location->get_selected_replica(r_replica_loc))) {
LOG_WARN("failed to get selected replica", K(ret), K(right_locations.at(i)));
} else if (!l_replica_loc.is_valid() || !r_replica_loc.is_valid()) {
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("replica location is invalid", K(ret), K(i), K(l_replica_loc), K(r_replica_loc));
} else {
is_physical_equal = l_replica_loc.get_server() == r_replica_loc.get_server();
}
if (OB_SUCC(ret) && is_physical_equal) {
r_array->at(i) = r_tablet_id;
}
}
// destroy hash map anyway
int tmp_ret = OB_SUCCESS;
if (OB_SUCCESS != (tmp_ret = l_tablet_id_map.destroy()) ||
OB_SUCCESS != (tmp_ret = r_tablet_id_map.destroy())) {
LOG_WARN("failed to destroy hash map", K(ret));
}
}
}
return ret;
}
int ObStrictPwjComparer::get_used_partition_indexes(const int64_t part_count,
const ObIArray<int64_t> &all_partition_indexes,
ObIArray<int64_t> &used_partition_indexes)
{
int ret = OB_SUCCESS;
bool part_idx[part_count];
MEMSET(part_idx, 0, part_count);
for (int64_t i = 0; i < all_partition_indexes.count(); ++i) {
if (part_count <= all_partition_indexes.at(i)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected part count", K(part_count), K(all_partition_indexes));
} else {
part_idx[all_partition_indexes.at(i)] = true;
}
}
for (int64_t i = 0; OB_SUCC(ret) && i < part_count; ++i) {
if (part_idx[i]) {
ret = used_partition_indexes.push_back(i);
}
}
// for (int64_t i = 0; OB_SUCC(ret) && i < part_count; ++i) {
// if (ObOptimizerUtil::find_item(all_partition_indexes, i)) {
// if (OB_FAIL(used_partition_indexes.push_back(i))) {
// LOG_WARN("failed to push back ob partition", K(ret));
// }
// }
// }
return ret;
}
int ObStrictPwjComparer::check_logical_equal_and_calc_match_map(const PwjTable &l_table,
const PwjTable &r_table,
bool &is_match)
{
int ret = OB_SUCCESS;
is_match = true;
part_tablet_id_map_.reuse();
part_index_map_.reuse();
subpart_tablet_id_map_.reuse();
phy_part_map_.reuse();
LOG_TRACE("start to check logical equal for l_table and r_table", K(l_table), K(r_table));
if (l_table.part_level_ != r_table.part_level_ ||
l_table.is_partition_single_ != r_table.is_partition_single_ ||
l_table.is_subpartition_single_ != r_table.is_subpartition_single_) {
is_match = false;
} else if (l_table.is_partition_single_ && r_table.is_partition_single_) {
std::pair<int64_t, int64_t> part_index_pair;
std::pair<uint64_t, uint64_t> part_tablet_id_pair;
part_index_pair.first = l_table.all_partition_indexes_.at(0);
part_index_pair.second = r_table.all_partition_indexes_.at(0);
if (OB_FAIL(get_part_tablet_id_by_part_index(l_table, part_index_pair.first, part_tablet_id_pair.first))) {
LOG_WARN("failed to get part id by part index", K(ret));
} else if (OB_FAIL(get_part_tablet_id_by_part_index(r_table, part_index_pair.second, part_tablet_id_pair.second))) {
LOG_WARN("failed to get part id by part index", K(ret));
} else if (OB_FAIL(part_tablet_id_map_.push_back(part_tablet_id_pair))) {
LOG_WARN("failed to push back part id pair", K(ret));
} else if (OB_FAIL(part_index_map_.push_back(part_index_pair))) {
LOG_WARN("failed to push back part index pair", K(ret));
}
} else if (OB_FAIL(is_first_partition_logically_equal(l_table, r_table, is_match))) {
LOG_WARN("failed to compare logical equal partition", K(ret));
}
if (OB_SUCC(ret) && is_match) {
if (PARTITION_LEVEL_TWO == l_table.part_level_) {
if (l_table.is_subpartition_single_ && r_table.is_subpartition_single_) {
uint64_t l_subpart_tablet_id = 0;
uint64_t r_subpart_tablet_id = 0;
for (int64_t i = 0; OB_SUCC(ret) && i < part_index_map_.count(); ++i) {
if (OB_FAIL(get_sub_part_tablet_id(l_table, part_index_map_.at(i).first, l_subpart_tablet_id))) {
LOG_WARN("failed to get sub part id", K(ret));
} else if (OB_FAIL(get_sub_part_tablet_id(r_table, part_index_map_.at(i).second, r_subpart_tablet_id))) {
LOG_WARN("failed to get sub part id", K(ret));
} else if (OB_FAIL(phy_part_map_.set_refactored(l_subpart_tablet_id,
r_subpart_tablet_id))) {
LOG_WARN("failed to set refactored", K(ret));
}
}
} else if (OB_FAIL(is_sub_partition_logically_equal(l_table, r_table, is_match))) {
LOG_WARN("failed to compare logical equal subpartition", K(ret));
}
// 一级分区表partition_id(物理分区id) = part_id(一级逻辑分区id)
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < part_tablet_id_map_.count(); ++i) {
if (OB_FAIL(phy_part_map_.set_refactored(part_tablet_id_map_.at(i).first, part_tablet_id_map_.at(i).second))) {
LOG_WARN("failed to set refactored", K(ret));
}
}
}
}
return ret;
}
bool ObStrictPwjComparer::is_same_part_type(const ObPartitionFuncType part_type1,
const ObPartitionFuncType part_type2)
{
bool ret = false;
if (part_type1 != part_type2)
{
if (PARTITION_FUNC_TYPE_RANGE_COLUMNS == part_type1
&& is_interval_part(part_type2)) {
ret = true;
} else if (PARTITION_FUNC_TYPE_RANGE_COLUMNS == part_type2
&& is_interval_part(part_type1)) {
ret = true;
}
} else {
ret = true;
}
return ret;
}
int ObStrictPwjComparer::is_first_partition_logically_equal(const PwjTable &l_table,
const PwjTable &r_table,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = true;
ObSEArray<int64_t, 128> l_used_partition_indexes;
ObSEArray<int64_t, 128> r_used_partition_indexes;
if (!is_same_part_type(l_table.part_type_, r_table.part_type_)) {
is_equal = false;
} else if (OB_FAIL(get_used_partition_indexes(l_table.part_number_,
l_table.all_partition_indexes_,
l_used_partition_indexes))) {
LOG_WARN("failed to get used partition indexes", K(ret));
} else if (OB_FAIL(get_used_partition_indexes(r_table.part_number_,
r_table.all_partition_indexes_,
r_used_partition_indexes))) {
LOG_WARN("failed to get used partition indexes", K(ret));
} else if (l_used_partition_indexes.count() != r_used_partition_indexes.count()) {
is_equal = false;
} else if (is_hash_like_part(l_table.part_type_)) {
// hash/key分区, 要求分区数量必须一致, 且左表每一个part_index都有一个相等的右表part_index
if (OB_FAIL(check_hash_partition_equal(l_table,
r_table,
l_used_partition_indexes,
r_used_partition_indexes,
part_tablet_id_map_,
part_index_map_,
is_equal))) {
LOG_WARN("failed to check hash partition equal", K(ret));
}
} else if (is_range_part(l_table.part_type_)) {
// range分区, 要求对应的分区上界一致
if (OB_FAIL(check_range_partition_equal(l_table.partition_array_,
r_table.partition_array_,
l_used_partition_indexes,
r_used_partition_indexes,
part_tablet_id_map_,
part_index_map_,
is_equal))) {
LOG_WARN("failed to get range partition match map", K(ret));
}
} else if (is_list_part(l_table.part_type_)) {
// list分区, 要求左侧的每一个分区能在右侧找到对应的分区
if (OB_FAIL(check_list_partition_equal(l_table.partition_array_,
r_table.partition_array_,
l_used_partition_indexes,
r_used_partition_indexes,
part_tablet_id_map_,
part_index_map_,
is_equal))) {
LOG_WARN("failed to get list partition match map", K(ret));
}
} else {
is_equal = false;
}
LOG_TRACE("succeed to check is first partition logical equal",
K(is_equal), K(part_tablet_id_map_), K(part_index_map_));
return ret;
}
int ObStrictPwjComparer::is_sub_partition_logically_equal(const PwjTable &l_table,
const PwjTable &r_table,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = true;
ObSEArray<int64_t, 128> l_used_partition_indexes;
ObSEArray<int64_t, 128> r_used_partition_indexes;
if (l_table.subpart_type_ != r_table.subpart_type_) {
is_equal = false;
} else {
ObPartition *l_part = NULL;
ObPartition *r_part = NULL;
for (int64_t i = 0; OB_SUCC(ret) && is_equal && i < part_tablet_id_map_.count(); ++i) {
int64_t l_part_index = part_index_map_.at(i).first;
int64_t r_part_index = part_index_map_.at(i).second;
l_used_partition_indexes.reuse();
r_used_partition_indexes.reuse();
subpart_tablet_id_map_.reuse();
if (OB_ISNULL(l_part = l_table.partition_array_[part_index_map_.at(i).first]) ||
OB_ISNULL(r_part = r_table.partition_array_[part_index_map_.at(i).second])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(get_subpartition_indexes_by_part_index(l_table, l_part_index,
l_used_partition_indexes))) {
LOG_WARN("failed to get subpartition indexes by part index", K(ret));
} else if (OB_FAIL(get_subpartition_indexes_by_part_index(r_table, r_part_index,
r_used_partition_indexes))) {
LOG_WARN("failed to get subpartition indexes by part index", K(ret));
} else if (l_used_partition_indexes.count() != r_used_partition_indexes.count()) {
is_equal = false;
} else if (is_hash_like_part(l_table.subpart_type_)) {
// hash/key分区, 要求分区数量必须一致, 且左表每一个part_index都有一个相等的右表part_index
if (l_part->get_sub_part_num() != r_part->get_sub_part_num()) {
is_equal = false;
} else if (OB_FAIL(check_hash_subpartition_equal(l_part->get_subpart_array(),
r_part->get_subpart_array(),
l_used_partition_indexes,
r_used_partition_indexes,
subpart_tablet_id_map_,
is_equal))) {
LOG_WARN("failed to get hash subpartition match map", K(ret));
}
} else if (is_range_part(l_table.subpart_type_)) {
// range分区, 要求使用到的分区数一致, 且对应的分区上界一致
if (OB_FAIL(check_range_subpartition_equal(l_part->get_subpart_array(),
r_part->get_subpart_array(),
l_used_partition_indexes,
r_used_partition_indexes,
subpart_tablet_id_map_,
is_equal))) {
LOG_WARN("failed to get range subpartition match map", K(ret));
}
} else if (is_list_part(l_table.subpart_type_)) {
// list分区, 要求使用到的分区数一致, 且左侧的每一个分区能在右侧找到对应的分区
if (OB_FAIL(check_list_subpartition_equal(l_part->get_subpart_array(),
r_part->get_subpart_array(),
l_used_partition_indexes,
r_used_partition_indexes,
subpart_tablet_id_map_,
is_equal))) {
LOG_WARN("failed to get list subpartition match map", K(ret));
}
} else {
is_equal = false;
}
if (OB_SUCC(ret) && is_equal) {
for (int64_t j = 0; OB_SUCC(ret) && j < subpart_tablet_id_map_.count(); ++j) {
if (OB_FAIL(phy_part_map_.set_refactored(subpart_tablet_id_map_.at(j).first,
subpart_tablet_id_map_.at(j).second))) {
LOG_WARN("failed to set refactored", K(ret));
}
}
}
}
}
LOG_TRACE("succeed to check is sub partition logical equal", K(is_equal), K(l_table), K(r_table));
return ret;
}
int ObStrictPwjComparer::get_subpartition_indexes_by_part_index(const PwjTable &table,
const int64_t part_index,
ObIArray<int64_t> &used_subpart_indexes)
{
int ret = OB_SUCCESS;
for (int64_t i = 0; OB_SUCC(ret) && i < table.all_partition_indexes_.count(); ++i) {
if (part_index != table.all_partition_indexes_.at(i)) {
// do nothing
} else if (OB_FAIL(used_subpart_indexes.push_back(table.all_subpartition_indexes_.at(i)))) {
LOG_WARN("failed to push back subpartition indexes", K(ret));
}
}
if (OB_SUCC(ret)) {
std::sort(&used_subpart_indexes.at(0), &used_subpart_indexes.at(0) + used_subpart_indexes.count());
}
return ret;
}
int ObStrictPwjComparer::check_hash_partition_equal(const PwjTable &l_table,
const PwjTable &r_table,
const ObIArray<int64_t> &l_indexes,
const ObIArray<int64_t> &r_indexes,
ObIArray<std::pair<uint64_t,uint64_t> > &part_tablet_id_map,
ObIArray<std::pair<int64_t,int64_t> > &part_index_map,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = true;
// hash分区还不支持分区管理，part_id一定等于part_index，不需要遍历part_array
if (l_table.part_number_ != r_table.part_number_) {
is_equal = false;
} else {
for (int64_t i = 0; OB_SUCC(ret) && is_equal && i < l_indexes.count(); ++i) {
std::pair<uint64_t, uint64_t> part_tablet_id_pair;
std::pair<int64_t, int64_t> part_index_pair;
if (l_indexes.at(i) == r_indexes.at(i)) {
part_index_pair.first = l_indexes.at(i);
part_index_pair.second = r_indexes.at(i);
if (OB_ISNULL(l_table.partition_array_) ||
OB_ISNULL(r_table.partition_array_) ||
OB_ISNULL(l_table.partition_array_[l_indexes.at(i)]) ||
OB_ISNULL(r_table.partition_array_[r_indexes.at(i)])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(l_table.partition_array_),
K(r_table.partition_array_));
} else {
part_tablet_id_pair.first = l_table.partition_array_[l_indexes.at(i)]->get_tablet_id().id();
part_tablet_id_pair.second = r_table.partition_array_[r_indexes.at(i)]->get_tablet_id().id();
if (OB_FAIL(part_tablet_id_map.push_back(part_tablet_id_pair))) {
LOG_WARN("failed to push back part id pair", K(ret));
} else if (OB_FAIL(part_index_map.push_back(part_index_pair))) {
LOG_WARN("failed to push back part index pair", K(ret));
} else { /* do nothing*/ }
}
} else {
is_equal = false;
}
}
}
return ret;
}
int ObStrictPwjComparer::check_hash_subpartition_equal(ObSubPartition **l_subpartition_array,
ObSubPartition **r_subpartition_array,
const ObIArray<int64_t> &l_indexes,
const ObIArray<int64_t> &r_indexes,
ObIArray<std::pair<uint64_t,uint64_t> > &subpart_tablet_id_map,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = true;
// hash分区还不支持分区管理，part_id一定等于part_index，不需要遍历part_array
UNUSED(l_subpartition_array);
UNUSED(r_subpartition_array);
for (int64_t i = 0; OB_SUCC(ret) && is_equal && i < l_indexes.count(); ++i) {
std::pair<uint64_t, uint64_t> subpart_tablet_id_pair;
if (l_indexes.at(i) == r_indexes.at(i)) {
if (OB_ISNULL(l_subpartition_array) || OB_ISNULL(r_subpartition_array) ||
OB_ISNULL(l_subpartition_array[l_indexes.at(i)]) ||
OB_ISNULL(r_subpartition_array[r_indexes.at(i)])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected error", K(ret), K(l_subpartition_array), K(r_subpartition_array));
} else {
subpart_tablet_id_pair.first = l_subpartition_array[l_indexes.at(i)]->get_tablet_id().id();
subpart_tablet_id_pair.second = r_subpartition_array[r_indexes.at(i)]->get_tablet_id().id();
if (OB_FAIL(subpart_tablet_id_map.push_back(subpart_tablet_id_pair))) {
LOG_WARN("failed to push back part id pair", K(ret));
}
}
} else {
is_equal = false;
}
}
return ret;
}
int ObStrictPwjComparer::check_range_partition_equal(ObPartition **l_partition_array,
ObPartition **r_partition_array,
const ObIArray<int64_t> &l_indexes,
const ObIArray<int64_t> &r_indexes,
ObIArray<std::pair<uint64_t,uint64_t> > &part_tablet_id_map,
ObIArray<std::pair<int64_t,int64_t> > &part_index_map,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = true;
const ObPartition *l_partition = NULL;
const ObPartition *r_partition = NULL;
if (OB_ISNULL(l_partition_array) || OB_ISNULL(r_partition_array)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(l_partition_array), K(r_partition_array));
}
for (int64_t i = 0; OB_SUCC(ret) && is_equal && i < l_indexes.count(); ++i) {
std::pair<uint64_t, uint64_t> part_tablet_id_pair;
std::pair<int64_t, int64_t> part_index_pair;
if (OB_ISNULL(l_partition = l_partition_array[l_indexes.at(i)]) ||
OB_ISNULL(r_partition = r_partition_array[r_indexes.at(i)])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(l_partition), K(r_partition), K(i));
} else if (OB_FAIL(is_partition_equal(l_partition, r_partition, true, is_equal))) {
LOG_WARN("failed to check range partition equal", K(ret));
} else if (is_equal) {
part_index_pair.first = l_indexes.at(i);
part_index_pair.second = r_indexes.at(i);
part_tablet_id_pair.first = l_partition->get_tablet_id().id();
part_tablet_id_pair.second = r_partition->get_tablet_id().id();
if (OB_FAIL(part_tablet_id_map.push_back(part_tablet_id_pair))) {
LOG_WARN("failed to push back part id pair", K(ret));
} else if (OB_FAIL(part_index_map.push_back(part_index_pair))) {
LOG_WARN("failed to push back part index pair", K(ret));
} else { /* do nothing*/ }
}
}
return ret;
}
int ObStrictPwjComparer::check_range_subpartition_equal(ObSubPartition **l_subpartition_array,
ObSubPartition **r_subpartition_array,
const ObIArray<int64_t> &l_indexes,
const ObIArray<int64_t> &r_indexes,
ObIArray<std::pair<uint64_t,uint64_t> > &subpart_tablet_id_map,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = true;
const ObSubPartition *l_partition = NULL;
const ObSubPartition *r_partition = NULL;
if (OB_ISNULL(l_subpartition_array) || OB_ISNULL(r_subpartition_array)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(l_subpartition_array), K(r_subpartition_array));
}
for (int64_t i = 0; OB_SUCC(ret) && is_equal && i < l_indexes.count(); ++i) {
std::pair<uint64_t, uint64_t> subpart_tablet_id_pair;
if (OB_ISNULL(l_partition = l_subpartition_array[l_indexes.at(i)]) ||
OB_ISNULL(r_partition = r_subpartition_array[r_indexes.at(i)])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(is_subpartition_equal(l_partition, r_partition, true, is_equal))) {
LOG_WARN("failed to check range subpartition equal", K(ret));
} else if (is_equal) {
subpart_tablet_id_pair.first = l_partition->get_tablet_id().id();
subpart_tablet_id_pair.second = r_partition->get_tablet_id().id();
if (OB_FAIL(subpart_tablet_id_map.push_back(subpart_tablet_id_pair))) {
LOG_WARN("failed to push back part id pair", K(ret));
}
}
}
return ret;
}
int ObStrictPwjComparer::check_list_partition_equal(ObPartition **l_partition_array,
ObPartition **r_partition_array,
const ObIArray<int64_t> &l_indexes,
const ObIArray<int64_t> &r_indexes,
ObIArray<std::pair<uint64_t,uint64_t> > &part_tablet_id_map,
ObIArray<std::pair<int64_t,int64_t> > &part_index_map,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = true;
const ObPartition *l_partition = NULL;
const ObPartition *r_partition = NULL;
ObSqlBitSet<> matched_partitions;
if (OB_ISNULL(l_partition_array) || OB_ISNULL(r_partition_array)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(l_partition_array), K(r_partition_array));
}
for (int64_t i = 0; OB_SUCC(ret) && is_equal && i < l_indexes.count(); ++i) {
bool find = false;
bool is_part_equal = false;
std::pair<uint64_t, uint64_t> part_tablet_id_pair;
std::pair<int64_t, int64_t> part_index_pair;
if (OB_ISNULL(l_partition = l_partition_array[l_indexes.at(i)])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && !find && j < r_indexes.count(); ++j) {
if (matched_partitions.has_member(j)) {
// do nothing
} else if (OB_ISNULL(r_partition = r_partition_array[r_indexes.at(j)])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(is_partition_equal(l_partition, r_partition, false, is_part_equal))) {
LOG_WARN("failed to check list partition equal", K(ret));
} else if (is_part_equal) {
find = true;
part_index_pair.first = l_indexes.at(i);
part_index_pair.second = r_indexes.at(j);
part_tablet_id_pair.first = l_partition->get_tablet_id().id();
part_tablet_id_pair.second = r_partition->get_tablet_id().id();
if (OB_FAIL(matched_partitions.add_member(j))) {
LOG_WARN("failed to add member", K(ret));
} else if (OB_FAIL(part_tablet_id_map.push_back(part_tablet_id_pair))) {
LOG_WARN("failed to push back part id pair", K(ret));
} else if (OB_FAIL(part_index_map.push_back(part_index_pair))) {
LOG_WARN("failed to push back part index pair", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (!find) {
is_equal = false;
}
}
}
return ret;
}
int ObStrictPwjComparer::check_list_subpartition_equal(ObSubPartition **l_subpartition_array,
ObSubPartition **r_subpartition_array,
const ObIArray<int64_t> &l_indexes,
const ObIArray<int64_t> &r_indexes,
ObIArray<std::pair<uint64_t,uint64_t> > &subpart_tablet_id_map,
bool &is_equal)
{
int ret = OB_SUCCESS;
is_equal = true;
const ObSubPartition *l_partition = NULL;
const ObSubPartition *r_partition = NULL;
ObSqlBitSet<> matched_partitions;
if (OB_ISNULL(l_subpartition_array) || OB_ISNULL(l_subpartition_array)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(l_subpartition_array), K(r_subpartition_array));
}
for (int64_t i = 0; OB_SUCC(ret) && is_equal && i < l_indexes.count(); ++i) {
bool find = false;
bool is_subpart_equal = false;
std::pair<uint64_t, uint64_t> subpart_tablet_id_pair;
if (OB_ISNULL(l_partition = l_subpartition_array[l_indexes.at(i)])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
}
for (int64_t j = 0; OB_SUCC(ret) && !find && j < r_indexes.count(); ++j) {
if (matched_partitions.has_member(j)) {
// do nothing
} else if (OB_ISNULL(r_partition = r_subpartition_array[r_indexes.at(j)])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else if (OB_FAIL(is_subpartition_equal(l_partition, r_partition, false, is_subpart_equal))) {
LOG_WARN("failed to check list partition equal", K(ret));
} else if (is_subpart_equal) {
find = true;
subpart_tablet_id_pair.first = l_partition->get_tablet_id().id();
subpart_tablet_id_pair.second = r_partition->get_tablet_id().id();
if (OB_FAIL(matched_partitions.add_member(j))) {
LOG_WARN("failed to add member", K(ret));
} else if (OB_FAIL(subpart_tablet_id_map.push_back(subpart_tablet_id_pair))) {
LOG_WARN("failed to push back part id pair", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (!find) {
is_equal = false;
}
}
}
return ret;
}
int ObStrictPwjComparer::get_part_tablet_id_by_part_index(const PwjTable &table,
const int64_t part_index,
uint64_t &tablet_id)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(table.partition_array_) ||
OB_ISNULL(table.partition_array_[part_index])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(table.partition_array_), K(part_index));
} else {
tablet_id = table.partition_array_[part_index]->get_tablet_id().id();
}
return ret;
}
int ObStrictPwjComparer::get_sub_part_tablet_id(const PwjTable &table,
const int64_t &part_index,
uint64_t &sub_part_tablet_id)
{
int ret = OB_SUCCESS;
ObPartition *part = NULL;
if (OB_ISNULL(table.partition_array_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret), K(table.partition_array_));
} else {
bool find = false;
for (int64_t i = 0; OB_SUCC(ret) && !find && i < table.all_partition_indexes_.count(); ++i) {
if (part_index == table.all_partition_indexes_.at(i)) {
int64_t subpart_index = table.all_subpartition_indexes_.at(i);
if (OB_ISNULL(part = table.partition_array_[part_index]) ||
OB_ISNULL(part->get_subpart_array()) ||
OB_ISNULL(part->get_subpart_array()[subpart_index])) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("get unexpected null", K(ret));
} else {
sub_part_tablet_id = part->get_subpart_array()[subpart_index]->get_tablet_id().id();
find = true;
}
}
}
if (OB_SUCC(ret) && !find) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to find part_index in all_partition_indexes", K(ret),
K(part_index), K(table.all_partition_indexes_));
}
}
return ret;
}
int ObNonStrictPwjComparer::add_table(PwjTable &table, bool &is_match_nonstrict_pw)
{
int ret = OB_SUCCESS;
is_match_nonstrict_pw = true;
if (table.server_list_.empty()) {
is_match_nonstrict_pw = false;
LOG_DEBUG("invalid non strict pwj input", K(table));
} else if (OB_FAIL(pwj_tables_.push_back(table))) {
LOG_WARN("failed to push back pwj table", K(ret));
} else if (pwj_tables_.count() <= 1) {
is_match_nonstrict_pw = true;
} else if (OB_FAIL(is_match_non_strict_partition_wise(pwj_tables_.at(0),
pwj_tables_.at(pwj_tables_.count() - 1),
is_match_nonstrict_pw))) {
LOG_WARN("failed to check non strict pw", K(ret));
}
return ret;
}
int ObNonStrictPwjComparer::is_match_non_strict_partition_wise(PwjTable &l_table,
PwjTable &r_table,
bool &is_match_nonstrict_pw)
{
int ret = OB_SUCCESS;
is_match_nonstrict_pw = false;
if (OB_FAIL(ObShardingInfo::is_physically_equal_serverlist(l_table.server_list_,
r_table.server_list_,
is_match_nonstrict_pw))) {
LOG_WARN("failed to check physically equal server list", K(ret));
} else if (is_match_nonstrict_pw) {
// do nothing
} else if (OB_FAIL(ObShardingInfo::is_physically_both_shuffled_serverlist(l_table.server_list_,
r_table.server_list_,
is_match_nonstrict_pw))) {
LOG_WARN("failed to check both shuffled server list", K(ret));
} else {
// do nothing
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink