pass tablet_handle when query

mittest/mtlenv/storage/blocksstable/ob_index_block_data_prepare.h

@@ -137,7 +137,6 @@ protected:
   int64_t mirco_blocks_per_macro_block_;
   bool is_cg_data_;
   bool is_ddl_merge_data_;
-  ObGetTableParam get_table_param_;
 
 };
 
@@ -299,8 +298,7 @@ void TestIndexBlockDataPrepare::SetUp()
 
   ASSERT_EQ(OB_SUCCESS, TestTabletHelper::create_tablet(ls_handle, tablet_id, table_schema_, allocator_));
   ASSERT_EQ(OB_SUCCESS, ls_handle.get_ls()->get_tablet(tablet_id, tablet_handle_));
-  get_table_param_.tablet_iter_.set_tablet_handle(tablet_handle_);
+  iter_param_.set_tablet_handle(&tablet_handle_);
-  iter_param_.set_table_param(&get_table_param_);
   sstable_.key_.table_type_ = ObITable::TableType::COLUMN_ORIENTED_SSTABLE;
 
   if (is_cg_data_ && is_ddl_merge_data_) {

src/storage/access/ob_index_tree_prefetcher.cpp

@@ -123,7 +123,7 @@ int ObIndexTreePrefetcher::init_basic_info(
         ret = OB_INVALID_ARGUMENT;
         LOG_WARN("invalid iter param", K(ret), KPC(iter_param_), K(lbt()));
       } else {
-        const ObTablet *cur_tablet = OB_ISNULL(iter_param_->get_table_param_) ? nullptr : iter_param_->get_table_param_->tablet_iter_.get_tablet();
+        const ObTablet *cur_tablet = OB_ISNULL(iter_param_->tablet_handle_) ? nullptr : iter_param_->tablet_handle_->get_obj();
         index_scanner_.switch_context(sstable, cur_tablet, *datum_utils_, *access_ctx_);
       }
     } else if (OB_FAIL(init_index_scanner(index_scanner_))) {
@@ -279,7 +279,7 @@ int ObIndexTreePrefetcher::init_index_scanner(ObIndexBlockRowScanner &index_scan
     ret = OB_INVALID_ARGUMENT;
     LOG_WARN("invalid iter param", K(ret), KPC(iter_param_), K(lbt()));
   } else {
-    const ObTablet *cur_tablet = OB_ISNULL(iter_param_->get_table_param_) ? nullptr : iter_param_->get_table_param_->tablet_iter_.get_tablet();
+    const ObTablet *cur_tablet = OB_ISNULL(iter_param_->tablet_handle_) ? nullptr : iter_param_->tablet_handle_->get_obj();
     index_scanner.set_iter_param(sstable_, cur_tablet);
   }
   return ret;
@@ -789,7 +789,7 @@ int ObIndexTreeMultiPassPrefetcher<DATA_PREFETCH_DEPTH, INDEX_PREFETCH_DEPTH>::s
           ret = OB_INVALID_ARGUMENT;
           LOG_WARN("invalid iter param", K(ret), KPC(iter_param_), K(lbt()));
         } else {
-          const ObTablet *cur_tablet = OB_ISNULL(iter_param_->get_table_param_) ? nullptr : iter_param_->get_table_param_->tablet_iter_.get_tablet();
+          const ObTablet *cur_tablet = OB_ISNULL(iter_param_->tablet_handle_) ? nullptr : iter_param_->tablet_handle_->get_obj();
           tree_handles_[level].index_scanner_.switch_context(sstable, cur_tablet, *datum_utils_, *access_ctx_);
         }
       } else if (OB_FAIL(init_index_scanner(tree_handles_[level].index_scanner_))) {

src/storage/access/ob_multiple_merge.cpp

@@ -146,7 +146,7 @@ int ObMultipleMerge::init(
     }
     unprojected_row_.count_ = 0;
     get_table_param_ = &get_table_param;
-    access_param_->iter_param_.set_table_param(get_table_param_);
+    access_param_->iter_param_.set_tablet_handle(get_table_param.tablet_iter_.get_tablet_handle_ptr());
     const ObITableReadInfo *read_info = access_param_->iter_param_.get_read_info();
     const int64_t batch_size = access_param_->iter_param_.vectorized_enabled_ ? access_param_->get_op()->get_batch_size() : 1;
     if (OB_SUCC(ret)) {
@@ -193,7 +193,7 @@ int ObMultipleMerge::switch_param(
   access_param_ = &param;
   access_ctx_ = &context;
   get_table_param_ = &get_table_param;
-  access_param_->iter_param_.set_table_param(get_table_param_);
+  access_param_->iter_param_.set_tablet_handle(get_table_param.tablet_iter_.get_tablet_handle_ptr());
 
   if (OB_FAIL(prepare_read_tables())) {
     STORAGE_LOG(WARN, "Failed to prepare read tables", K(ret), K(*this));

src/storage/access/ob_rows_info.cpp

@@ -74,6 +74,7 @@ int ObRowsInfo::ExistHelper::init(const ObRelativeTable &table,
       table_iter_param_.tablet_id_ = table.get_tablet_id();
       table_iter_param_.out_cols_project_ = NULL;
       table_iter_param_.read_info_ = &rowkey_read_info;
+      table_iter_param_.set_tablet_handle(table.get_tablet_handle());
       is_inited_ = true;
     }
   }

src/storage/access/ob_table_access_param.cpp

@@ -31,7 +31,7 @@ ObTableIterParam::ObTableIterParam()
       tablet_id_(),
       read_info_(nullptr),
       rowkey_read_info_(nullptr),
-      get_table_param_(nullptr),
+      tablet_handle_(nullptr),
       cg_read_info_handle_(),
       out_cols_project_(NULL),
       agg_cols_project_(NULL),
@@ -66,7 +66,7 @@ void ObTableIterParam::reset()
   tablet_id_.reset();
   read_info_ = nullptr;
   rowkey_read_info_ = nullptr;
-  get_table_param_ = nullptr;
+  tablet_handle_ = nullptr;
   cg_read_info_handle_.reset();
   out_cols_project_ = NULL;
   agg_cols_project_ = NULL;
@@ -217,6 +217,7 @@ int ObTableAccessParam::init(
     iter_param_.tablet_id_ = scan_param.tablet_id_;
     iter_param_.read_info_ = &table_param.get_read_info();
     iter_param_.rowkey_read_info_ = &tablet_handle.get_obj()->get_rowkey_read_info();
+    iter_param_.set_tablet_handle(&tablet_handle);
     iter_param_.out_cols_project_ = &table_param.get_output_projector();
     iter_param_.agg_cols_project_ = &table_param.get_aggregate_projector();
     iter_param_.group_by_cols_project_ = &table_param.get_group_by_projector();
@@ -332,6 +333,7 @@ int ObTableAccessParam::init_merge_param(
     iter_param_.is_multi_version_minor_merge_ = is_multi_version_minor_merge;
     iter_param_.read_info_ = &read_info;
     iter_param_.rowkey_read_info_ = &read_info;
+    // merge_query will not goto ddl_merge_query, no need to pass tablet
     is_inited_ = true;
   }
   return ret;
@@ -353,6 +355,7 @@ int ObTableAccessParam::init_dml_access_param(
     iter_param_.tablet_id_ = table.get_tablet_id();
     iter_param_.read_info_ = &schema_param.get_read_info();
     iter_param_.rowkey_read_info_ = &rowkey_read_info;
+    iter_param_.set_tablet_handle(table.tablet_iter_.get_tablet_handle_ptr());
     iter_param_.is_same_schema_column_ =
         iter_param_.read_info_->get_schema_column_count() == iter_param_.rowkey_read_info_->get_schema_column_count();
     iter_param_.out_cols_project_ = out_cols_project;

src/storage/access/ob_table_access_param.h

@@ -141,8 +141,8 @@ public:
   { return pd_storage_flag_.set_use_column_store(true); }
   OB_INLINE void set_not_use_column_store()
   { return pd_storage_flag_.set_use_column_store(false); }
-  OB_INLINE void set_table_param(const ObGetTableParam *get_table_param)
+  OB_INLINE void set_tablet_handle(const ObTabletHandle *tablet_handle)
-  { get_table_param_ = get_table_param; }
+  { tablet_handle_ = tablet_handle; }
   OB_INLINE bool use_uniform_format() const
   {
     return op_->enable_rich_format_ &&
@@ -161,7 +161,7 @@ public:
   uint32_t cg_idx_;
   const ObITableReadInfo *read_info_;
   const ObITableReadInfo *rowkey_read_info_;
-  const ObGetTableParam *get_table_param_;
+  const ObTabletHandle *tablet_handle_; //for ddl merge_query
   ObCGReadInfoHandle cg_read_info_handle_;
   //TODO(huronghui.hrh):temp solution
   const ObColumnParam *cg_col_param_;

src/storage/column_store/ob_cg_iter_param_pool.cpp

@@ -75,7 +75,7 @@ int ObCGIterParamPool::get_iter_param(
         LOG_WARN("Unexpected null iter param", K(ret));
       } else if (tmp_param->can_be_reused(cg_idx, exprs, is_aggregate)) {
         iter_param = tmp_param;
-        iter_param->get_table_param_ = row_param.get_table_param_;
+        iter_param->tablet_handle_ = row_param.tablet_handle_;
         break;
       }
     }
@@ -200,7 +200,7 @@ int ObCGIterParamPool::fill_virtual_cg_iter_param(
     cg_param.output_exprs_ = output_exprs;
     cg_param.op_ = row_param.op_;
     cg_param.pd_storage_flag_ = row_param.pd_storage_flag_;
-    cg_param.get_table_param_ = row_param.get_table_param_;
+    cg_param.tablet_handle_ = row_param.tablet_handle_;
   }
   if (OB_FAIL(ret) && nullptr != output_exprs) {
     output_exprs->reset();
@@ -255,7 +255,7 @@ int ObCGIterParamPool::generate_for_column_store(const ObTableIterParam &row_par
     cg_param.tablet_id_ = row_param.tablet_id_;
     cg_param.cg_idx_ = cg_idx;
     cg_param.read_info_ = cg_param.cg_read_info_handle_.get_read_info();
-    cg_param.get_table_param_ = row_param.get_table_param_;
+    cg_param.tablet_handle_ = row_param.tablet_handle_;
     cg_param.cg_col_param_ = col_param;
     cg_param.out_cols_project_ = out_cols_project;
     cg_param.agg_cols_project_ = nullptr;

src/storage/meta_mem/ob_tablet_handle.h

@@ -93,6 +93,7 @@ public:
   const ObTablet *get_tablet() const { return tablet_handle_.get_obj(); }
   ObTablet *get_tablet() { return tablet_handle_.get_obj(); }
   const ObTabletHandle &get_tablet_handle() { return tablet_handle_; }
+  const ObTabletHandle *get_tablet_handle_ptr() const { return &tablet_handle_; }
   int set_tablet_handle(const ObTabletHandle &tablet_handle);
   int set_transfer_src_tablet_handle(const ObTabletHandle &tablet_handle);
   int refresh_read_tables_from_tablet(

src/storage/ob_relative_table.cpp

@@ -77,6 +77,11 @@ const ObTabletID& ObRelativeTable::get_tablet_id() const
   return tablet_id_;
 }
 
+const ObTabletHandle* ObRelativeTable::get_tablet_handle() const
+{
+  return tablet_iter_.get_tablet_handle_ptr();
+}
+
 int64_t ObRelativeTable::get_schema_version() const
 {
   return schema_param_->get_schema_version();

src/storage/ob_relative_table.h

@@ -58,6 +58,7 @@ public:
       const bool allow_not_ready = false);
   uint64_t get_table_id() const;
   const ObTabletID& get_tablet_id() const;
+  const ObTabletHandle *get_tablet_handle() const;
   int64_t get_schema_version() const;
   int get_col_desc(const uint64_t column_id, share::schema::ObColDesc &col_desc) const;
   int get_col_desc_by_idx(const int64_t idx, share::schema::ObColDesc &col_desc) const;

src/storage/tablet/ob_tablet.cpp

@@ -5808,7 +5808,7 @@ int ObTablet::prepare_param(
   param.table_id_ = relative_table.get_table_id();
   param.tablet_id_ = tablet_meta_.tablet_id_;
   param.read_info_ = rowkey_read_info_;
-
+  param.set_tablet_handle(relative_table.get_tablet_handle());
   return ret;
 }