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

#ifndef OCEANBASE_SQL_OPTIMIZER_OB_PWJ_COMPARER_H
#define OCEANBASE_SQL_OPTIMIZER_OB_PWJ_COMPARER_H 1
#include "lib/container/ob_array.h"
#include "share/partition_table/ob_partition_location.h"
#include "sql/optimizer/ob_table_partition_info.h"
#include "sql/resolver/expr/ob_raw_expr.h"
#include "sql/optimizer/ob_sharding_info.h"

namespace oceanbase
{
namespace sql
{
class ObRawExpr;
class ObOptimizerContext;
class ObDMLStmt;
class ObLogPlan;

//Do not allocate a PwjTable on the heap. If it is necessary to allocate a PwjTable on the heap, manually free it after its lifecycle ends.
struct PwjTable {
  PwjTable()
    : phy_table_loc_info_(NULL),
      server_list_(),
      part_level_(share::schema::PARTITION_LEVEL_ZERO),
      part_type_(share::schema::PARTITION_FUNC_TYPE_MAX),
      subpart_type_(share::schema::PARTITION_FUNC_TYPE_MAX),
      is_partition_single_(false),
      is_subpartition_single_(false),
      partition_array_(NULL),
      part_number_(-1)
  {}

  virtual ~PwjTable() {}

  int assign(const PwjTable &other);

  int init(const ObShardingInfo &info);
  int init(const share::schema::ObTableSchema &table_schema,
           const ObCandiTableLoc &phy_tbl_info);
  int init(const ObIArray<ObAddr> &server_list);

  TO_STRING_KV(K_(part_level), K_(part_type), K_(subpart_type),
               K_(part_number),
               K_(is_partition_single), K_(is_subpartition_single),
               K_(all_partition_indexes), K_(all_subpartition_indexes),
               K_(server_list));

  const ObCandiTableLoc *phy_table_loc_info_;
  ObSEArray<common::ObAddr, 8> server_list_;
  // 分区级别
  share::schema::ObPartitionLevel part_level_;
  // 一级分区类型
  share::schema::ObPartitionFuncType part_type_;
  // 二级分区类型
  share::schema::ObPartitionFuncType subpart_type_;
  // 二级分区表的phy_table_location_info_中，是否只涉及到一个一级分区
  bool is_partition_single_;
  // 二级分区表的phy_table_location_info_中，是否每个一级分区都只涉及一个二级分区
  bool is_subpartition_single_;
  // 一级分区array
  share::schema::ObPartition **partition_array_;
  // 一级分区数量
  int64_t part_number_;
  // phy_table_location_info_中所有的partition_id(物理分区id)
  // ObPwjComparer在生成_id的映射关系时要按照左表这个数组中的partition_id的顺序生成
  common::ObSEArray<uint64_t, 8> ordered_tablet_ids_;
  // phy_table_location_info_中每一个partition_id(物理分区id)的
  // part_id(一级逻辑分区id)在part_array中的偏移
  common::ObSEArray<int64_t, 8> all_partition_indexes_;
  // phy_table_location_info_中每一个partition_id(物理分区id)的
  // subpart_id(二级逻辑分区id)在subpart_array中的偏移
  common::ObSEArray<int64_t, 8> all_subpartition_indexes_;
};

// TODO yibo 用PartitionIdArray的指针作为value, 否则每次get都要拷贝一次array
typedef common::ObSEArray<uint64_t, 8> TabletIdArray;
typedef common::hash::ObHashMap<uint64_t, TabletIdArray, common::hash::NoPthreadDefendMode> PWJTabletIdMap;
typedef common::hash::ObHashMap<uint64_t, uint64_t, common::hash::NoPthreadDefendMode,
                                common::hash::hash_func<uint64_t>,
                                common::hash::equal_to<uint64_t>,
                                common::hash::SimpleAllocer<typename common::hash::HashMapTypes<uint64_t, uint64_t>::AllocType>,
                                common::hash::NormalPointer,
                                oceanbase::common::ObMalloc,
                                2> TabletIdIdMap;
typedef common::hash::ObHashMap<uint64_t, const ObCandiTabletLoc *,
                                common::hash::NoPthreadDefendMode> TabletIdLocationMap;

//Do not allocate a ObPwjComparer on the heap. If it is necessary to allocate a ObPwjComparer on the heap, manually free it after its lifecycle ends.
class ObPwjComparer
{
public:
  ObPwjComparer(bool is_strict)
    : is_strict_(is_strict), pwj_tables_() {};
  virtual ~ObPwjComparer() {};
  virtual void reset();

  inline bool get_is_strict() { return is_strict_; }

  inline common::ObIArray<PwjTable> &get_pwj_tables() { return pwj_tables_; }

  /**
   * 向ObPwjComparer中添加一个PwjTable，会以第一个添加的PwjTable为基准与后续添加的PwjTable进行比较
   * 其中严格比较会生成tablet_id的映射。
   */
  virtual int add_table(PwjTable &table, bool &is_match_pwj);

  /**
   * 从phy_table_location_info中提取以下分区相关的信息
   * @param all_partition_ids:
   *    phy_table_location_info中所有的partition_id(物理分区id)
   * @param all_partition_indexes:
   *    phy_table_location_info中每一个partition_id(物理分区id)的
   *    part_id(一级逻辑分区id)在part_array中的偏移
   * @param all_subpartition_indexes:
   *    phy_table_location_info中每一个partition_id(物理分区id)的
   *    subpart_id(二级逻辑分区id)在subpart_array中的偏移
   * @param is_partition_single:
   *    二级分区表的phy_table_location_info_中，是否只涉及到一个一级分区
   * @param is_subpartition_single:
   *    二级分区表的phy_table_location_info_中，是否每个一级分区都只涉及一个二级分区
   */
  static int extract_all_partition_indexes(const ObCandiTableLoc &phy_table_location_info,
                                           const share::schema::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);

  /**
   * 检查l_partition和r_partition的定义是否相等
   */
  static int is_partition_equal(const share::schema::ObPartition *l_partition,
                                const share::schema::ObPartition *r_partition,
                                const bool is_range_partition,
                                bool &is_equal);

  /**
   * 检查l_subpartition和r_subpartition的定义是否相等
   */
  static int is_subpartition_equal(const share::schema::ObSubPartition *l_subpartition,
                                   const share::schema::ObSubPartition *r_subpartition,
                                   const bool is_range_partition,
                                   bool &is_equal);

  static int is_row_equal(const ObRowkey &first_row,
                          const ObRowkey &second_row,
                          bool &is_equal);

  static int is_list_partition_equal(const share::schema::ObBasePartition *first_partition,
                                     const share::schema::ObBasePartition *second_partition,
                                     bool &is_equal);

  static int is_row_equal(const common::ObNewRow &first_row,
                          const common::ObNewRow &second_row,
                          bool &is_equal);

  static int is_obj_equal(const common::ObObj &first_obj,
                          const common::ObObj &second_obj,
                          bool &is_equal);

  TO_STRING_KV(K_(is_strict), K_(pwj_tables));

protected:
  // 是否以严格模式检查partition wise join
  // 严格模式要求两个基表的分区逻辑上和物理上都相等
  // 非严格模式要求两个基表的数据分布节点相同
  bool is_strict_;
  // 保存一组pwj约束涉及到的基表信息
  common::ObSEArray<PwjTable, 4> pwj_tables_;
  static const int64_t MIN_ID_LOCATION_BUCKET_NUMBER;
  static const int64_t DEFAULT_ID_ID_BUCKET_NUMBER;
  DISALLOW_COPY_AND_ASSIGN(ObPwjComparer);
};

class ObStrictPwjComparer : public ObPwjComparer
{
public:
  ObStrictPwjComparer();
  virtual ~ObStrictPwjComparer();
  virtual void reset() override;
  inline common::ObIArray<TabletIdArray> &get_tablet_id_group() { return tablet_id_group_;}

  /**
   * 向ObPwjComparer中添加一个PwjTable，会以第一个添加的PwjTable为基准与后续添加的PwjTable进行严格比较
   * 并生成tablet_id的映射。
   */
  virtual int add_table(PwjTable &table, bool &is_match_pwj) override;

  /**
   * 检查l_table和r_table的分区是否逻辑上相等，并计算出逻辑上相等的partition_id(物理分区id)的映射
   */
  int check_logical_equal_and_calc_match_map(const PwjTable &l_table,
                                             const PwjTable &r_table,
                                             bool &is_match);

  /**
   * 检查l_table和r_table的一级分区是否逻辑上相等
   */
  int is_first_partition_logically_equal(const PwjTable &l_table,
                                         const PwjTable &r_table,
                                         bool &is_equal);

  /**
   * 从所有(sub)part_index中按照升序取出用到的(sub)part_index
   * 例如 all_partition_indexes = [0,0,3,3,1] 可以得到 used_partition_indexes = [0,1,3]
   */
  int get_used_partition_indexes(const int64_t part_count,
                                 const ObIArray<int64_t> &all_partition_indexes,
                                 ObIArray<int64_t> &used_partition_indexes);

  /**
   * 检查l_table和r_table的二级分区是否逻辑上相等
   */
  int is_sub_partition_logically_equal(const PwjTable &l_table,
                                       const PwjTable &r_table,
                                       bool &is_equal);

  /**
   * 获取指定part_index下的所有用到的二级分区的subpart_index，并按升序排列
   */
  int get_subpartition_indexes_by_part_index(const PwjTable &table,
                                             const int64_t part_index,
                                             ObIArray<int64_t> &used_subpart_indexes);

  /**
   * 检查一级hash/key分区是否逻辑上相等, 要求:
   * 1. 左右表分区数量一致
   * 2. 左表每一个part_index都有一个相等的右表part_index
   */
  int 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);

  /**
   * 检查二级hash/key分区是否逻辑上相等, 要求:
   * 1. 左右表分区数量一致
   * 2. 左表每一个subpart_index都有一个相等的右表subpart_index
   */
  int check_hash_subpartition_equal(share::schema::ObSubPartition **l_subpartition_array,
                                    share::schema::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);

  bool is_same_part_type(const ObPartitionFuncType part_type1,
                         const ObPartitionFuncType part_type2);

  /**
   * 检查一级range分区是否逻辑上相等, 要求:
   * 1. 左右表对应分区的上界相同
   */
  int check_range_partition_equal(share::schema::ObPartition **left_partition_array,
                                  share::schema::ObPartition **right_partition_array,
                                  const ObIArray<int64_t> &left_indexes,
                                  const ObIArray<int64_t> &right_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);

  /**
   * 检查二级range分区是否逻辑上相等, 要求:
   * 1. 左右表对应分区的上界相同
   */
  int check_range_subpartition_equal(share::schema::ObSubPartition **left_subpartition_array,
                                     share::schema::ObSubPartition **right_subpartition_array,
                                     const ObIArray<int64_t> &left_indexes,
                                     const ObIArray<int64_t> &right_indexes,
                                     ObIArray<std::pair<uint64_t,uint64_t> > &subpart_tablet_id_map,
                                     bool &is_equal);

  /**
   * 检查一级list分区是否逻辑上相等, 要求:
   * 1. 左表的每一个分区能在右表找到边界相同的分区
   */
  int check_list_partition_equal(share::schema::ObPartition **left_partition_array,
                                 share::schema::ObPartition **right_partition_array,
                                 const ObIArray<int64_t> &left_indexes,
                                 const ObIArray<int64_t> &right_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);

  /**
   * 检查二级list分区是否逻辑上相等, 要求:
   * 1. 左表的每一个分区能在右表找到边界相同的分区
   */
  int check_list_subpartition_equal(share::schema::ObSubPartition **left_subpartition_array,
                                    share::schema::ObSubPartition **right_subpartition_array,
                                    const ObIArray<int64_t> &left_indexes,
                                    const ObIArray<int64_t> &right_indexes,
                                    ObIArray<std::pair<uint64_t,uint64_t> > &subpart_tablet_id_map,
                                    bool &is_equal);

  /**
   * 根据phy_part_map_中的partition_id(物理分区id)的映射关系，检查两表对应的分区是否物理位置相同
   */
  int is_physically_equal_partitioned(const PwjTable &l_table,
                                      const PwjTable &r_table,
                                      bool &is_physical_equal);

  /**
   * 获取part_index(一级逻辑分区在part_array中的偏移)对应分区的part_id(一级逻辑分区id)
   */
  int get_part_tablet_id_by_part_index(const PwjTable &table,
                                       const int64_t part_index,
                                       uint64_t &tablet_id);

  /**
   * 获取二级分区表某个part_index对应的二级分区的subpart_id(二级逻辑分区id)
   */
  int get_sub_part_tablet_id(const PwjTable &table,
                             const int64_t &part_index,
                             uint64_t &sub_part_tablet_id);

private:
  // 保存基表part_id(一级逻辑分区id)的映射关系
  common::ObSEArray<std::pair<uint64_t, uint64_t>, 8, common::ModulePageAllocator, true> part_tablet_id_map_;
  // 保存基表part_index(一级逻辑分区在part_array中的偏移)的映射关系
  common::ObSEArray<std::pair<int64_t, int64_t>, 8, common::ModulePageAllocator, true> part_index_map_;
  // 保存基表subpart_id(二级逻辑分区id)的映射关系
  common::ObSEArray<std::pair<uint64_t, uint64_t>, 8, common::ModulePageAllocator, true> subpart_tablet_id_map_;
  // 保存基表partition_id(物理分区id)的映射关系
  TabletIdIdMap phy_part_map_;
  // 保存一组pwj约束中基表的tablet_id的映射关系
  // 例如 pwj约束中包括[t1,t2,t3],
  //      t1,t2 的tablet_id映射关系是 [0,1,2] <-> [1,2,0]
  //      t2,t3 的tablet_id映射关系是 [0,1,2] <-> [2,1,0]
  // tablet_id_group_ = [[0,1,2], [1,2,0], [1,0,2]]
  common::ObSEArray<TabletIdArray, 4, common::ModulePageAllocator, true> tablet_id_group_;
  DISALLOW_COPY_AND_ASSIGN(ObStrictPwjComparer);
};

class ObNonStrictPwjComparer : public ObPwjComparer
{
public:
  ObNonStrictPwjComparer()
    : ObPwjComparer(false) {};
  virtual ~ObNonStrictPwjComparer() {};
  /**
   * 向ObPwjComparer中添加一个PwjTable，会以第一个添加的PwjTable为基准与后续添加的PwjTable进行非严格比较
   */
  virtual int add_table(PwjTable &table, bool &is_match_nonstrict_pw) override;
  /**
   * check left table and right table have at least one partition on corresponding server
   */
  int is_match_non_strict_partition_wise(PwjTable &l_table,
                                         PwjTable &r_table,
                                         bool &is_match_nonstrict_pw);
private:
  DISALLOW_COPY_AND_ASSIGN(ObNonStrictPwjComparer);
};
}
}
#endif