/**
 * 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_INDEX_INFO_CACHE_H
#define OCEANBASE_SQL_OPTIMIZER_OB_INDEX_INFO_CACHE_H 1

#include "sql/rewrite/ob_query_range.h"
#include "sql/ob_sql_define.h"

namespace oceanbase
{
namespace sql
{

/* 缓存query range的信息 */
class QueryRangeInfo {
public:
  QueryRangeInfo() : is_valid_(false),
      contain_always_false_(false),
      query_range_(NULL),
      ranges_(),
      ss_ranges_(),
      equal_prefix_count_(0),
      equal_prefix_null_count_(0),
      range_prefix_count_(0),
      index_column_count_(0),
      range_columns_(),
      expr_constraints_() {}
  const ObQueryRange* get_query_range() const { return query_range_; }
  const ObQueryRangeArray& get_ranges() const { return ranges_; }
  const common::ObIArray<ColumnItem> &get_range_columns() const { return range_columns_; }
  const common::ObIArray<ObExprConstraint> &get_expr_constraints() const
  {
    return expr_constraints_;
  }
  uint64_t get_equal_prefix_count() const { return equal_prefix_count_; };
  uint64_t get_equal_prefix_null_count() const { return equal_prefix_null_count_; };
  uint64_t get_range_prefix_count() const { return range_prefix_count_; };
  uint64_t get_index_column_count() const { return index_column_count_; };
  bool get_contain_always_false() const { return contain_always_false_; }
  
  ObQueryRangeArray& get_ranges() { return ranges_; }
  ObQueryRangeArray& get_ss_ranges() { return ss_ranges_; }
  const ObQueryRangeArray& get_ss_ranges() const { return ss_ranges_; }
  void set_query_range(ObQueryRange *query_range) { query_range_ = query_range; }
  common::ObIArray<ColumnItem> &get_range_columns() { return range_columns_; }
  common::ObIArray<ObExprConstraint> &get_expr_constraints() { return expr_constraints_; }
  void set_valid() { is_valid_ = true; }
  bool is_valid() const { return is_valid_; }
  bool is_get() const
  {
    return is_valid_ && (equal_prefix_count_ == range_columns_.count());
  }
  bool has_valid_range_condition() const
  {
    return equal_prefix_count_ > 0 || range_prefix_count_ > 0;
  }
  bool is_index_column_get() const
  {
    return is_valid_ && (equal_prefix_count_ >= index_column_count_);
  }
  bool equal_prefix_has_null() const
  {
    return equal_prefix_null_count_ > 0;
  }
  bool equal_prefix_all_null() const
  {
    return is_valid_ && equal_prefix_null_count_ == equal_prefix_count_;
  }
  void set_equal_prefix_count(const int64_t equal_prefix_count)
  { equal_prefix_count_ = equal_prefix_count; }
  void set_equal_prefix_null_count(const int64_t equal_prefix_null_count)
  { equal_prefix_null_count_ = equal_prefix_null_count; }
  void set_range_prefix_count(const int64_t range_prefix_count)
  { range_prefix_count_ = range_prefix_count; }
  void set_index_column_count(const int64_t index_column_count)
  { index_column_count_ = index_column_count; };
  void set_contain_always_false(const bool contain_always_false)
  { contain_always_false_ = contain_always_false; }

  TO_STRING_KV(K_(is_valid), K_(contain_always_false), K_(range_columns), K_(equal_prefix_count),
               K_(equal_prefix_null_count), K_(range_prefix_count),
               K_(index_column_count), K_(expr_constraints));
private:
  bool is_valid_;
  bool contain_always_false_;
  ObQueryRange *query_range_;
  ObQueryRangeArray ranges_;
  ObQueryRangeArray ss_ranges_; // for index skip scan, postfix range
  int64_t equal_prefix_count_;
  int64_t equal_prefix_null_count_;
  int64_t range_prefix_count_;
  int64_t index_column_count_; // index column count without adding primary key
  common::ObArray<ColumnItem> range_columns_;
  common::ObArray<ObExprConstraint> expr_constraints_;
  DISALLOW_COPY_AND_ASSIGN(QueryRangeInfo);
};


/* 索引的ordering 信息 */
class OrderingInfo {
public:
  OrderingInfo() :
    scan_direction_(default_asc_direction()),
    index_keys_(),
    ordering_(){
  }
  ObOrderDirection get_scan_direction() const { return scan_direction_; }
  const common::ObIArray<ObRawExpr *> &get_index_keys() const { return index_keys_; }
  const common::ObIArray<ObRawExpr *> &get_ordering() const { return ordering_; }

  common::ObIArray<ObRawExpr *> &get_index_keys() { return index_keys_; }
  common::ObIArray<ObRawExpr *> &get_ordering() { return ordering_; }
  void set_scan_direction(const ObOrderDirection direction) { scan_direction_ = direction; }
  TO_STRING_KV(K_(scan_direction), K_(index_keys));
private:
  ObOrderDirection scan_direction_;
  common::ObArray<ObRawExpr*> index_keys_;
  common::ObArray<ObRawExpr*> ordering_;
  DISALLOW_COPY_AND_ASSIGN(OrderingInfo);
};

// 每个索引作为一个entry
class IndexInfoEntry {
public:
  IndexInfoEntry() :
    index_id_(common::OB_INVALID_ID),
    is_unique_index_(false),
    is_index_back_(false),
    is_index_global_(false),
    is_geo_index_(false),
    range_info_(),
    ordering_info_(),
    interesting_order_info_(OrderingFlag::NOT_MATCH),
    interesting_order_prefix_count_(0),
    partition_info_(NULL),
    sharding_info_(NULL) {
  }
  virtual ~IndexInfoEntry() {}
  QueryRangeInfo &get_range_info() { return range_info_; }
  const QueryRangeInfo &get_range_info() const { return range_info_; }
  OrderingInfo &get_ordering_info() { return ordering_info_; }
  const OrderingInfo &get_ordering_info() const { return ordering_info_; }
  int64_t get_interesting_order_info() const { return interesting_order_info_; }
  void set_interesting_order_info(int64_t info) { interesting_order_info_ = info; }
  int64_t get_interesting_order_prefix_count() const { return interesting_order_prefix_count_; }
  void set_interesting_order_prefix_count(int64_t count) { interesting_order_prefix_count_ = count; }
  uint64_t get_index_id() const { return index_id_; }
  void set_index_id(const uint64_t index_id) { index_id_ = index_id; }
  bool is_unique_index() const { return is_unique_index_; }
  bool is_valid_unique_index() const //唯一索引在query range中能否保持唯一
  {
    return is_unique_index_
           && !((lib::is_oracle_mode() && range_info_.equal_prefix_all_null())
                || (lib::is_mysql_mode() && (range_info_.equal_prefix_has_null()
                                             || !range_info_.is_index_column_get())));
  }
  void set_is_unique_index(const bool is_unique_index) { is_unique_index_ = is_unique_index; }
  bool is_index_back() const { return is_index_back_; }
  void set_is_index_back(const bool is_index_back) { is_index_back_ = is_index_back; }
  bool is_index_global() const { return is_index_global_; }
  void set_is_index_global(const bool is_index_global) { is_index_global_ = is_index_global; }
  bool is_index_geo() const { return is_geo_index_; }
  void set_is_index_geo(const bool is_index_geo) { is_geo_index_ = is_index_geo; }
  void set_partition_info(ObTablePartitionInfo *partition_info) { partition_info_ = partition_info; }
  ObTablePartitionInfo *get_partition_info() const { return partition_info_; }
  void set_sharding_info(ObShardingInfo *sharding_info) { sharding_info_ = sharding_info; }
  ObShardingInfo *get_sharding_info() const { return sharding_info_; }
  TO_STRING_KV(K_(index_id), K_(is_unique_index), K_(is_index_back), K_(is_index_global),
               K_(range_info), K_(ordering_info), K_(interesting_order_info),
               K_(interesting_order_prefix_count));
private:
  uint64_t index_id_;
  bool is_unique_index_;
  bool is_index_back_;
  bool is_index_global_;
  bool is_geo_index_;
  QueryRangeInfo range_info_;
  OrderingInfo ordering_info_;
  int64_t interesting_order_info_;  // 记录索引的序在stmt中的哪些地方用到 e.g. join, group by, order by
  // 索引序在stmt中使用到的最大前缀数
  // idx1(a,b,c), idx2(a,b),  对于order by a,b 两个索引使用到的最大前缀都是2
  int64_t interesting_order_prefix_count_;
  ObTablePartitionInfo *partition_info_;
  ObShardingInfo *sharding_info_;
  DISALLOW_COPY_AND_ASSIGN(IndexInfoEntry);
};


/* 对优化器过程中抽取的query range 做一些缓存，减少计算的次数 */
class ObIndexInfoCache
{
public:
  ObIndexInfoCache() : table_id_(common::OB_INVALID_ID),
    base_table_id_(common::OB_INVALID_ID),
    entry_count_(0)
  {
    MEMSET(index_entrys_, 0, sizeof(index_entrys_));
  }
  virtual ~ObIndexInfoCache();
  int get_query_range(const uint64_t table_id,
                      const uint64_t index_id,
                      const QueryRangeInfo *&query_range_info) const;
  int get_access_path_ordering(const uint64_t table_id,
                               const uint64_t index_id,
                               const OrderingInfo *&ordering_info) const;
  int get_index_info_entry(const uint64_t table_id,
                           const uint64_t index_id,
                           IndexInfoEntry *&entry) const;
  void set_table_id(const uint64_t table_id) { table_id_ = table_id; }
  void set_base_table_id(const uint64_t base_table_id) { base_table_id_ = base_table_id; }
  uint64_t get_table_id() const { return table_id_; }
  int add_index_info_entry(IndexInfoEntry *);
  TO_STRING_KV(K_(table_id), K_(base_table_id), K_(entry_count));
private:
  uint64_t table_id_;
  uint64_t base_table_id_;
  int64_t entry_count_;
  IndexInfoEntry *index_entrys_[common::OB_MAX_INDEX_PER_TABLE + 1]; //including table and index table
  DISALLOW_COPY_AND_ASSIGN(ObIndexInfoCache);
};

} //end of namespace sql
} //end of namespace oceanbase

#endif